Routing via resolve!

Author: david-driscoll

src/Protocol/Document/ICodeLensResolveHandler.cs

@@ -12,5 +12,5 @@ public static partial class DocumentNames
     }
 
     [Parallel, Method(CodeLensResolve)]
-    public interface ICodeLensResolveHandler : IRequestHandler<CodeLens, CodeLens> { }
+    public interface ICodeLensResolveHandler : ICanBeResolvedHandler<CodeLens> { }
 }

src/Protocol/Document/ICompletionResolveHandler.cs

@@ -12,5 +12,5 @@ public static partial class DocumentNames
     }
 
     [Serial, Method(CompletionResolve)]
-    public interface ICompletionResolveHandler : IRequestHandler<CompletionItem, CompletionItem> { }
+    public interface ICompletionResolveHandler : ICanBeResolvedHandler<CompletionItem> { }
 }

src/Protocol/Models/CompletionList.cs

@@ -9,14 +9,22 @@ namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
     /// Represents a collection of [completion items](#CompletionItem) to be presented
     /// in the editor.
     /// </summary>
-    public class CompletionList
+    public class CompletionList : Container<CompletionItem>
     {
-        public CompletionList(IEnumerable<CompletionItem> items)
+        public CompletionList() : base(Enumerable.Empty<CompletionItem>()) { }
+        public CompletionList(bool isIncomplete) : base(Enumerable.Empty<CompletionItem>())
         {
-            Items = items;
+            IsIncomplete = isIncomplete;
+        }
+
+        public CompletionList(IEnumerable<CompletionItem> items) : base(items) { }
+        public CompletionList(IEnumerable<CompletionItem> items, bool isIncomplete) : base(items)
+        {
+            IsIncomplete = isIncomplete;
         }
 
-        public CompletionList(IEnumerable<CompletionItem> items, bool isIncomplete) : this(items)
+        public CompletionList(params CompletionItem[] items) : base(items) { }
+        public CompletionList(bool isIncomplete, params CompletionItem[] items) : base(items)
         {
             IsIncomplete = isIncomplete;
         }
@@ -30,7 +38,7 @@ public CompletionList(IEnumerable<CompletionItem> items, bool isIncomplete) : th
         /// <summary>
         /// The completion items.
         /// </summary>
-        public IEnumerable<CompletionItem> Items { get; }
+        public IEnumerable<CompletionItem> Items => this;
 
         public static implicit operator CompletionList(CompletionItem[] items)
         {
@@ -49,7 +57,7 @@ public static implicit operator CompletionList(List<CompletionItem> items)
 
         public static implicit operator CompletionItem[] (CompletionList list)
         {
-            return list.Items.ToArray();
+            return list.ToArray();
         }
     }
 }

src/Protocol/Models/ICanBeResolved.cs

@@ -14,4 +14,4 @@ public interface ICanBeResolved
         [Optional]
         JToken Data { get; set; }
     }
-}
+}

src/Protocol/Models/ICanBeResolvedHandler.cs

@@ -0,0 +1,19 @@
+using OmniSharp.Extensions.JsonRpc;
+
+namespace OmniSharp.Extensions.LanguageServer.Protocol.Models
+{
+    /// <summary>
+    /// Common interface for types that support resolution.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public interface ICanBeResolvedHandler<T> : IRequestHandler<T, T>
+        where T : ICanBeResolved
+    {
+        /// <summary>
+        /// Method that determines if a handler can be used to resolve this one
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        bool CanResolve(T value);
+    }
+}

src/Protocol/Serialization/Converters/CompletionListConverter.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
@@ -13,7 +14,7 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
             var v = value as CompletionList;
             if (!v.IsIncomplete)
             {
-                serializer.Serialize(writer, v.Items);
+                serializer.Serialize(writer, v.Items.ToArray());
                 return;
             }
 

src/Server/Abstractions/ILspHandlerDescriptor.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using OmniSharp.Extensions.JsonRpc;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 
@@ -15,5 +15,6 @@ public interface ILspHandlerDescriptor : IHandlerDescriptor
         void SetCapability(object instance);
         bool IsDynamicCapability { get; }
         bool AllowsDynamicRegistration { get; }
+        Type CanBeResolvedHandlerType { get; }
     }
 }

src/Server/HandlerDescriptor.cs

@@ -23,6 +23,10 @@ public HandlerDescriptor(string method, string key, IJsonRpcHandler handler, Typ
             Params = @params;
             RegistrationType = registrationType;
             CapabilityType = capabilityType;
+            if (@params != null && typeof(ICanBeResolved).GetTypeInfo().IsAssignableFrom(@params))
+            {
+                CanBeResolvedHandlerType = typeof(ICanBeResolvedHandler<>).MakeGenericType(@params);
+            }
         }
 
         public IJsonRpcHandler Handler { get; }
@@ -80,6 +84,7 @@ public void SetCapability(object instance)
 
         public bool IsDynamicCapability => typeof(DynamicCapability).GetTypeInfo().IsAssignableFrom(CapabilityType);
         public bool AllowsDynamicRegistration { get; private set; }
+        public Type CanBeResolvedHandlerType { get; }
 
         public void Dispose()
         {

src/Server/Matchers/ResolveCommandMatcher.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json.Linq;
 using OmniSharp.Extensions.LanguageServer.Protocol;
@@ -11,6 +12,7 @@ namespace OmniSharp.Extensions.LanguageServer.Server.Matchers
     public class ResolveCommandMatcher : IHandlerMatcher, IHandlerPostProcessorMatcher, IHandlerPostProcessor
     {
         private readonly ILogger _logger;
+        internal static string PrivateHandlerTypeName = "$$___handlerType___$$";
 
         public ResolveCommandMatcher(ILogger logger)
         {
@@ -27,17 +29,32 @@ public IEnumerable<ILspHandlerDescriptor> FindHandler(object parameters, IEnumer
         {
             if (parameters is ICanBeResolved canBeResolved)
             {
-                var handlerType = canBeResolved.Data?.Value<string>("handlerType");
+                var handlerType = canBeResolved.Data?.Value<string>(PrivateHandlerTypeName);
                 if (string.IsNullOrWhiteSpace(handlerType))
                 {
-                    var descriptor = descriptors.FirstOrDefault();
+                    foreach (var descriptor in descriptors)
+                    {
+                        if (descriptor.CanBeResolvedHandlerType?.GetTypeInfo().IsAssignableFrom(descriptor.Handler.GetType()) == true)
+                        {
+                            var method = typeof(ResolveCommandMatcher).GetTypeInfo()
+                                .GetMethod(nameof(CanResolve), BindingFlags.NonPublic | BindingFlags.Static)
+                                .MakeGenericMethod(descriptor.Params);
+                            if ((bool)method.Invoke(null, new[] { descriptor.Handler, parameters }))
+                            {
+                                yield return descriptor;
+                                yield break;
+                            }
+                        }
+                    }
+
+                    var descriptor2 = descriptors.FirstOrDefault();
                     _logger.LogTrace(
                         "Resolve {Method} was called, but data did not have handle type defined.  Using Handler {HandlerType}",
-                        descriptor?.Method,
-                        descriptor?.Handler.GetType().FullName
+                        descriptor2?.Method,
+                        descriptor2?.Handler.GetType().FullName
                     );
 
-                    yield return descriptor;
+                    yield return descriptor2;
                     yield break;
                 }
                 foreach (var descriptor in descriptors)
@@ -54,6 +71,12 @@ public IEnumerable<ILspHandlerDescriptor> FindHandler(object parameters, IEnumer
             }
         }
 
+        private static bool CanResolve<T>(ICanBeResolvedHandler<T> handler, T value)
+            where T : ICanBeResolved
+        {
+            return handler.CanResolve(value);
+        }
+
         public IEnumerable<IHandlerPostProcessor> FindPostProcessor(ILspHandlerDescriptor descriptor, object parameters, object response)
         {
             if (descriptor.Method == DocumentNames.CodeLens || descriptor.Method == DocumentNames.Completion)
@@ -67,7 +90,9 @@ public IEnumerable<IHandlerPostProcessor> FindPostProcessor(ILspHandlerDescripto
 
         public object Process(ILspHandlerDescriptor descriptor, object parameters, object response)
         {
-            if (response is IEnumerable<ICanBeResolved> canBeResolveds)
+            // Only pin the handler type, if we know the source handler (codelens) is also the resolver.
+            if (response is IEnumerable<ICanBeResolved> canBeResolveds &&
+                descriptor.CanBeResolvedHandlerType.GetTypeInfo().IsAssignableFrom(descriptor.Handler.GetType()))
             {
                 _logger.LogTrace("Updating Resolve items with wrapped data for {Method}:{Handler}",
                     descriptor.Method,
@@ -77,10 +102,10 @@ public object Process(ILspHandlerDescriptor descriptor, object parameters, objec
                     // Originally we were going to change Data to be a JObject instead of JToken
                     // This allows us to leave data alone by simply wrapping it
                     // Since we're always going to intercept these items, we can control this.
-                    item.Data = new JObject(new {
-                        data = item.Data,
-                        handlerType = descriptor.HandlerType.FullName
-                    });
+                    var data = new JObject();
+                    data["data"] = item.Data;
+                    data[PrivateHandlerTypeName] = descriptor.Handler.GetType().FullName;
+                    item.Data = data;
                 }
             }
             return response;

test/Lsp.Tests/Matchers/ExecuteCommandHandlerMatcherTests.cs

@@ -3,7 +3,6 @@
 using System.Linq;
 using FluentAssertions;
 using Microsoft.Extensions.Logging;
-using Newtonsoft.Json.Linq;
 using NSubstitute;
 using OmniSharp.Extensions.LanguageServer;
 using OmniSharp.Extensions.LanguageServer.Protocol;
@@ -78,115 +77,4 @@ public void Should_Return_Handler_Descriptor()
             result.Should().Contain(x => x.Method == "workspace/executeCommand");
         }
     }
-    public class ResolveCommandMatcherTests
-    {
-        private readonly ILogger _logger;
-
-        public ResolveCommandMatcherTests()
-        {
-            _logger = Substitute.For<ILogger>();
-        }
-
-        [Fact]
-        public void Should_Not_Return_Null()
-        {
-            // Given
-            var handlerDescriptors = Enumerable.Empty<ILspHandlerDescriptor>();
-            var handlerMatcher = new ResolveCommandMatcher(_logger);
-
-            // When
-            var result = handlerMatcher.FindHandler(1, handlerDescriptors);
-
-            // Then
-            result.Should().NotBeNull();
-        }
-
-        [Fact]
-        public void Should_Return_Empty_Descriptor()
-        {
-            // Given
-            var handlerDescriptors = Enumerable.Empty<ILspHandlerDescriptor>();
-            var handlerMatcher = new ResolveCommandMatcher(_logger);
-
-            // When
-            var result = handlerMatcher.FindHandler(1, handlerDescriptors);
-
-            // Then
-            result.Should().BeEmpty();
-        }
-
-        [Fact]
-        public void Should_Return_CodeLensResolve_Descriptor()
-        {
-            // Given
-            var handlerMatcher = new ResolveCommandMatcher(_logger);
-            var resolveHandler = Substitute.For<ICodeLensResolveHandler>();
-            var resolveHandler2 = Substitute.For<ICodeLensResolveHandler>();
-
-            // When
-            var result = handlerMatcher.FindHandler(new CodeLens() {
-                        Data = JToken.FromObject(new { handlerType = typeof(ICodeLensResolveHandler).FullName, data = new { a = 1 } })
-                    },
-                    new List<HandlerDescriptor> {
-                        new HandlerDescriptor(DocumentNames.CodeLensResolve,
-                            "Key",
-                            resolveHandler,
-                            resolveHandler.GetType(),
-                            typeof(CodeLens),
-                            null,
-                            null,
-                            () => { }),
-                        new HandlerDescriptor(DocumentNames.CodeLensResolve,
-                            "Key2",
-                            resolveHandler2,
-                            typeof(ICodeLensResolveHandler),
-                            typeof(CodeLens),
-                            null,
-                            null,
-                            () => { }),
-                    })
-                .ToArray();
-
-            // Then
-            result.Should().NotBeNullOrEmpty();
-            result.Should().Contain(x => x.Handler == resolveHandler2);
-        }
-
-        [Fact]
-        public void Should_Return_CompletionResolve_Descriptor()
-        {
-            // Given
-            var handlerMatcher = new ResolveCommandMatcher(_logger);
-            var resolveHandler = Substitute.For<ICompletionResolveHandler>();
-            var resolveHandler2 = Substitute.For<ICompletionResolveHandler>();
-
-            // When
-            var result = handlerMatcher.FindHandler(new CodeLens() {
-                        Data = JToken.FromObject(new { handlerType = typeof(ICompletionResolveHandler).FullName, data = new { a = 1 } })
-                    },
-                    new List<HandlerDescriptor> {
-                        new HandlerDescriptor(DocumentNames.CompletionResolve,
-                            "Key",
-                            resolveHandler,
-                            resolveHandler.GetType(),
-                            typeof(CompletionItem),
-                            null,
-                            null,
-                            () => { }),
-                        new HandlerDescriptor(DocumentNames.CompletionResolve,
-                            "Key2",
-                            resolveHandler2,
-                            typeof(ICompletionResolveHandler),
-                            typeof(CompletionItem),
-                            null,
-                            null,
-                            () => { }),
-                    })
-                .ToArray();
-
-            // Then
-            result.Should().NotBeNullOrEmpty();
-            result.Should().Contain(x => x.Handler == resolveHandler2);
-        }
-    }
 }