IT's alive!!!

david-driscoll · david-driscoll · commit ac5fa098197a · 2017-04-24T20:53:36.000-04:00
diff --git a/sample/SampleServer/Program.cs b/sample/SampleServer/Program.cs
@@ -39,7 +39,10 @@ class TextDocumentHandler : ITextDocumentSyncHandler
         private readonly ILanguageServer _router;
 
         private readonly DocumentSelector _documentSelector = new DocumentSelector(
-            new DocumentFilter() { Pattern = "*.csproj" }
+            new DocumentFilter() {
+                //Pattern = "*.csproj",
+                Language = "xml"
+            }
         );
 
         private SynchronizationCapability _capability;
diff --git a/src/JsonRpc/InputHandler.cs b/src/JsonRpc/InputHandler.cs
@@ -134,47 +134,53 @@ private void HandleRequest(string request)
             {
                 foreach (var response in requests.Where(x => x.IsResponse).Select(x => x.Response))
                 {
-                    long id = response.Id is string s ? long.Parse(s) : response.Id is long l ? l : -1;
-
+                    var id = response.Id is string s ? long.Parse(s) : response.Id is long l ? l : -1;
                     if (id < 0) continue;
 
                     var tcs = _responseRouter.GetRequest(id);
                     if (tcs is null) continue;
 
-                    tcs.SetResult(response.Result);
-                }
-            }
-            else
-            {
-                foreach (var (type, item) in requests.Select(x => (_requestProcessIdentifier.Identify(x), x)))
-                {
-                    if (item.IsRequest)
+                    if (response.Error is null)
                     {
-                        _queue.Enqueue((
-                            type,
-                            async () => {
-                                var result = await _requestRouter.RouteRequest(item.Request);
-                                
-                                _outputHandler.Send(result.Value);
-                            }
-                        ));
+                        tcs.SetResult(response.Result);
                     }
-                    else if (item.IsNotification)
+                    else
                     {
-                        _queue.Enqueue((
-                            type,
-                            () => {
-                                _requestRouter.RouteNotification(item.Notification);
-                                return Task.CompletedTask;
-                            }
-                        ));
-                    }
-                    else if (item.IsError)
-                    {
-                        // TODO:
-                        _outputHandler.Send(item.Error);
+                        tcs.SetException(new Exception(response.Error));
                     }
                 }
+
+                return;
+            }
+
+            foreach (var (type, item) in requests.Select(x => (_requestProcessIdentifier.Identify(x), x)))
+            {
+                if (item.IsRequest)
+                {
+                    _queue.Enqueue((
+                        type,
+                        async () => {
+                            var result = await _requestRouter.RouteRequest(item.Request);
+
+                            _outputHandler.Send(result.Value);
+                        }
+                    ));
+                }
+                else if (item.IsNotification)
+                {
+                    _queue.Enqueue((
+                        type,
+                        () => {
+                            _requestRouter.RouteNotification(item.Notification);
+                            return Task.CompletedTask;
+                        }
+                    ));
+                }
+                else if (item.IsError)
+                {
+                    // TODO:
+                    _outputHandler.Send(item.Error);
+                }
             }
         }
 
diff --git a/src/JsonRpc/Reciever.cs b/src/JsonRpc/Reciever.cs
@@ -61,11 +61,16 @@ protected virtual Renor GetRenor(JToken @object)
                 requestId = idString ?? (idLong.HasValue ? (object)idLong.Value : null);
             }
 
-            if (request.TryGetValue("result", out var response))
+            if (hasRequestId && request.TryGetValue("result", out var response))
             {
                 return new Response(requestId, response);
             }
 
+            if (hasRequestId && request.TryGetValue("error", out var errorResponse))
+            {
+                return new Response(requestId, errorResponse.ToString());
+            }
+
             var method = request["method"]?.Value<string>();
             if (string.IsNullOrWhiteSpace(method))
             {
diff --git a/src/JsonRpc/ResponseRouter.cs b/src/JsonRpc/ResponseRouter.cs
@@ -26,7 +26,7 @@ public void SendNotification<T>(string method, T @params)
             });
         }
 
-        public Task<TResponse> SendRequest<T, TResponse>(string method, T @params)
+        public async Task<TResponse> SendRequest<T, TResponse>(string method, T @params)
         {
             long nextId;
             lock (_lock)
@@ -43,14 +43,18 @@ public Task<TResponse> SendRequest<T, TResponse>(string method, T @params)
                 Id = nextId
             });
 
-            return tcs.Task
-                .ContinueWith(x => {
-                    _requests.TryRemove(nextId, out var _);
-                    return x.Result.ToObject<TResponse>();
-                });
+            try
+            {
+                var result = await tcs.Task;
+                return result.ToObject<TResponse>();
+            }
+            finally
+            {
+                _requests.TryRemove(nextId, out var _);
+            }
         }
 
-        public Task SendRequest<T>(string method, T @params)
+        public async Task SendRequest<T>(string method, T @params)
         {
             long nextId;
             lock (_lock)
@@ -67,7 +71,14 @@ public Task SendRequest<T>(string method, T @params)
                 Id = nextId
             });
 
-            return tcs.Task.ContinueWith(x => _requests.TryRemove(nextId, out var _));
+            try
+            {
+                await tcs.Task;
+            }
+            finally
+            {
+                _requests.TryRemove(nextId, out var _);
+            }
         }
 
         public TaskCompletionSource<JToken> GetRequest(long id)
diff --git a/src/JsonRpc/Server/Response.cs b/src/JsonRpc/Server/Response.cs
@@ -6,20 +6,24 @@ namespace JsonRpc.Server
 {
     public class Response
     {
-        public Response(object id) : this(id, null)
+        public Response(object id, JToken result)
         {
+            Id = id;
+            Result = result;
         }
 
-        public Response(object id, JToken result)
+        public Response(object id, string error)
         {
             Id = id;
-            Result = result;
+            Error = error;
         }
 
         public string ProtocolVersion { get; set; } = "2.0";
 
         public object Id { get; set; }
 
         public JToken Result { get; set; }
+
+        public string Error { get; set; }
     }
 }
diff --git a/src/Lsp/HandlerCollection.cs b/src/Lsp/HandlerCollection.cs
@@ -12,7 +12,7 @@ namespace Lsp
 {
     class HandlerCollection : IHandlerCollection
     {
-        private readonly List<HandlerDescriptor> _handlers = new List<HandlerDescriptor>();
+        internal readonly HashSet<HandlerDescriptor> _handlers = new HashSet<HandlerDescriptor>();
 
         public IEnumerator<ILspHandlerDescriptor> GetEnumerator()
         {
@@ -50,12 +50,14 @@ public IDisposable Add(IJsonRpcHandler handler)
                     @params,
                     registration,
                     capability,
-                    () => _handlers.RemoveAll(instance => instance.Handler == handler));
+                    () => _handlers.RemoveWhere(instance => instance.Handler == handler));
 
                 handlers.Add(h);
             }
 
-            _handlers.AddRange(handlers);
+            foreach (var a in handlers)
+                _handlers.Add(a);
+
             return new ImutableDisposable(handlers);
         }
 
diff --git a/src/Lsp/HandlerDescriptor.cs b/src/Lsp/HandlerDescriptor.cs
@@ -88,5 +88,19 @@ private static void SetCapability<T>(ICapability<T> capability, T instance)
         {
             capability.SetCapability(instance);
         }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is HandlerDescriptor handler)
+            {
+                return handler.HandlerType == HandlerType;
+            }
+            return false;
+        }
+
+        public override int GetHashCode()
+        {
+            return HandlerType.GetHashCode();
+        }
     }
 }
diff --git a/src/Lsp/LanguageServer.cs b/src/Lsp/LanguageServer.cs
@@ -83,8 +83,6 @@ public async Task Initialize()
 
             await _initializeComplete.Task;
 
-            _reciever.Initialized();
-
             // Small delay to let client respond
             await Task.Delay(100);
 
@@ -150,15 +148,17 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
                 };
             }
 
+            _reciever.Initialized();
+
             // TODO: Need a call back here
             // serverCapabilities.Experimental;
 
             var result = Server = new InitializeResult() { Capabilities = serverCapabilities };
 
             // TODO:
-            _initializeComplete.SetResult(result);
             if (_clientVersion == ClientVersion.Lsp2)
             {
+                _initializeComplete.SetResult(result);
             }
 
             return result;
diff --git a/src/Lsp/Lsp.csproj b/src/Lsp/Lsp.csproj
@@ -11,4 +11,3 @@
     <ProjectReference Include="..\JsonRpc\JsonRpc.csproj" />
   </ItemGroup>
 </Project>
-
diff --git a/src/Lsp/Protocol/Client/RegisterCapabilityExtensions.cs b/src/Lsp/Protocol/Client/RegisterCapabilityExtensions.cs
@@ -1,4 +1,5 @@
-﻿using System.Threading.Tasks;
+﻿using System;
+using System.Threading.Tasks;
 using JsonRpc;
 using Lsp.Models;
 // ReSharper disable CheckNamespace
@@ -7,9 +8,17 @@ namespace Lsp.Protocol
 {
     public static class RegisterCapabilityExtensions
     {
-        public static Task RegisterCapability(this ILanguageServer mediator,  RegistrationParams @params)
+        public static async Task RegisterCapability(this ILanguageServer mediator,  RegistrationParams @params)
         {
-            return mediator.SendRequest("client/registerCapability", @params);
+            try
+            {
+                await mediator.SendRequest("client/registerCapability", @params);
+            }
+            catch (Exception e)
+            {
+                // VsCode today does not implement LSP properly.
+                await mediator.SendRequest("client/registerFeature", @params);
+            }
         }
     }
 }
diff --git a/src/Lsp/Protocol/Client/UnregisterCapabilityExtensions.cs b/src/Lsp/Protocol/Client/UnregisterCapabilityExtensions.cs
@@ -1,4 +1,5 @@
-﻿using System.Threading.Tasks;
+﻿using System;
+using System.Threading.Tasks;
 using JsonRpc;
 using Lsp.Models;
 // ReSharper disable CheckNamespace
@@ -7,9 +8,17 @@ namespace Lsp.Protocol
 {
     public static class UnregisterCapabilityExtensions
     {
-        public static Task UnregisterCapability(this ILanguageServer mediator, UnregistrationParams @params)
+        public static async Task UnregisterCapability(this ILanguageServer mediator, UnregistrationParams @params)
         {
-            return mediator.SendRequest("client/unregisterCapability", @params);
+            try
+            {
+                await mediator.SendRequest("client/unregisterCapability", @params);
+            }
+            catch (Exception e)
+            {
+                // VsCode today does not implement LSP properly.
+                await mediator.SendRequest("client/unregisterFeature", @params);
+            }
         }
     }
 }
diff --git a/test/JsonRpc.Tests/HandlerResolverTests.cs b/test/JsonRpc.Tests/HandlerResolverTests.cs
@@ -43,6 +43,7 @@ public void Should_Contain_AllDefinedMethods(Type requestHandler, string key)
         [InlineData(typeof(IRequestResponseHandler), "requestresponse", typeof(Request))]
         [InlineData(typeof(INotificationDataHandler), "notificationdata", null)]
         [InlineData(typeof(IInlineNotificationHandler), "notification", null)]
+        [InlineData(typeof(IInlineNotificationHandler), "notification", null)]
         public void Should_Have_CorrectParams(Type requestHandler, string key, Type expected)
         {
             var handler = new HandlerCollection();
diff --git a/test/Lsp.Tests/HandlerResolverTests.cs b/test/Lsp.Tests/HandlerResolverTests.cs
@@ -0,0 +1,43 @@
+﻿using System;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using JsonRpc;
+using Lsp.Protocol;
+using NSubstitute;
+using Xunit;
+
+namespace Lsp.Tests
+{
+    public class HandlerResolverTests
+    {
+
+        [Theory]
+        [InlineData(typeof(IInitializeHandler), "initialize", 1)]
+        [InlineData(typeof(IInitializedHandler), "initialized", 1)]
+        [InlineData(typeof(ITextDocumentSyncHandler), "textDocument/didOpen", 4)]
+        [InlineData(typeof(ITextDocumentSyncHandler), "textDocument/didChange", 4)]
+        [InlineData(typeof(ITextDocumentSyncHandler), "textDocument/didClose", 4)]
+        [InlineData(typeof(ITextDocumentSyncHandler), "textDocument/didSave", 4)]
+        public void Should_Contain_AllDefinedMethods(Type requestHandler, string key, int count)
+        {
+            var handler = new HandlerCollection();
+            handler.Add((IJsonRpcHandler)Substitute.For(new Type[] { requestHandler }, new object[0]));
+            handler._handlers.Should().Contain(x => x.Method == key);
+            handler._handlers.Count.Should().Be(count);
+        }
+
+        [Theory]
+        [InlineData(typeof(IInitializeHandler), typeof(IInitializedHandler), "initialize", "initialized", 2)]
+        public void Should_Contain_AllDefinedMethods_OnLanguageServer(Type requestHandler, Type type2, string key, string key2, int count)
+        {
+            var handler = new HandlerCollection();
+            handler.Add((IJsonRpcHandler)Substitute.For(new Type[] { requestHandler, type2 }, new object[0]));
+            handler._handlers.Should().Contain(x => x.Method == key);
+            handler._handlers.Should().Contain(x => x.Method == key2);
+            handler._handlers.Count.Should().Be(count);
+        }
+    }
+}
diff --git a/vscode-testextension/src/extension.ts b/vscode-testextension/src/extension.ts
@@ -26,7 +26,10 @@ export function activate(context: ExtensionContext) {
     // Options to control the language client
     let clientOptions: LanguageClientOptions = {
         // Register the server for plain text documents
-        documentSelector: ['xml'],
+        documentSelector: [{
+            language: 'xml',
+            pattern: '*.csproj'
+        }],
         synchronize: {
             // Synchronize the setting section 'languageServerExample' to the server
             configurationSection: 'languageServerExample',

Original file line number	Diff line number	Diff line change
`@@ -61,11 +61,16 @@ protected virtual Renor GetRenor(JToken @object)`
`61`	`61`	`requestId = idString ?? (idLong.HasValue ? (object)idLong.Value : null);`
`62`	`62`	`}`
`63`	`63`
`64`		`- if (request.TryGetValue("result", out var response))`
	`64`	`+ if (hasRequestId && request.TryGetValue("result", out var response))`
`65`	`65`	`{`
`66`	`66`	`return new Response(requestId, response);`
`67`	`67`	`}`
`68`	`68`
	`69`	`+ if (hasRequestId && request.TryGetValue("error", out var errorResponse))`
	`70`	`+ {`
	`71`	`+ return new Response(requestId, errorResponse.ToString());`
	`72`	`+ }`
	`73`	`+`
`69`	`74`	`var method = request["method"]?.Value<string>();`
`70`	`75`	`if (string.IsNullOrWhiteSpace(method))`
`71`	`76`	`{`
Original file line number	Diff line number	Diff line change
`@@ -6,20 +6,24 @@ namespace JsonRpc.Server`
`6`	`6`	`{`
`7`	`7`	`public class Response`
`8`	`8`	`{`
`9`		`- public Response(object id) : this(id, null)`
	`9`	`+ public Response(object id, JToken result)`
`10`	`10`	`{`
	`11`	`+ Id = id;`
	`12`	`+ Result = result;`
`11`	`13`	`}`
`12`	`14`
`13`		`- public Response(object id, JToken result)`
	`15`	`+ public Response(object id, string error)`
`14`	`16`	`{`
`15`	`17`	`Id = id;`
`16`		`- Result = result;`
	`18`	`+ Error = error;`
`17`	`19`	`}`
`18`	`20`
`19`	`21`	`public string ProtocolVersion { get; set; } = "2.0";`
`20`	`22`
`21`	`23`	`public object Id { get; set; }`
`22`	`24`
`23`	`25`	`public JToken Result { get; set; }`
	`26`	`+`
	`27`	`+ public string Error { get; set; }`
`24`	`28`	`}`
`25`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace Lsp`
`12`	`12`	`{`
`13`	`13`	`class HandlerCollection : IHandlerCollection`
`14`	`14`	`{`
`15`		`- private readonly List<HandlerDescriptor> _handlers = new List<HandlerDescriptor>();`
	`15`	`+ internal readonly HashSet<HandlerDescriptor> _handlers = new HashSet<HandlerDescriptor>();`
`16`	`16`
`17`	`17`	`public IEnumerator<ILspHandlerDescriptor> GetEnumerator()`
`18`	`18`	`{`
`@@ -50,12 +50,14 @@ public IDisposable Add(IJsonRpcHandler handler)`
`50`	`50`	`@params,`
`51`	`51`	`registration,`
`52`	`52`	`capability,`
`53`		`- () => _handlers.RemoveAll(instance => instance.Handler == handler));`
	`53`	`+ () => _handlers.RemoveWhere(instance => instance.Handler == handler));`
`54`	`54`
`55`	`55`	`handlers.Add(h);`
`56`	`56`	`}`
`57`	`57`
`58`		`- _handlers.AddRange(handlers);`
	`58`	`+ foreach (var a in handlers)`
	`59`	`+ _handlers.Add(a);`
	`60`	`+`
`59`	`61`	`return new ImutableDisposable(handlers);`
`60`	`62`	`}`
`61`	`63`
Original file line number	Diff line number	Diff line change
`@@ -88,5 +88,19 @@ private static void SetCapability<T>(ICapability<T> capability, T instance)`
`88`	`88`	`{`
`89`	`89`	`capability.SetCapability(instance);`
`90`	`90`	`}`
	`91`	`+`
	`92`	`+ public override bool Equals(object obj)`
	`93`	`+ {`
	`94`	`+ if (obj is HandlerDescriptor handler)`
	`95`	`+ {`
	`96`	`+ return handler.HandlerType == HandlerType;`
	`97`	`+ }`
	`98`	`+ return false;`
	`99`	`+ }`
	`100`	`+`
	`101`	`+ public override int GetHashCode()`
	`102`	`+ {`
	`103`	`+ return HandlerType.GetHashCode();`
	`104`	`+ }`
`91`	`105`	`}`
`92`	`106`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System.Threading.Tasks;`
	`1`	`+using System;`
	`2`	`+using System.Threading.Tasks;`
`2`	`3`	`using JsonRpc;`
`3`	`4`	`using Lsp.Models;`
`4`	`5`	`// ReSharper disable CheckNamespace`
`@@ -7,9 +8,17 @@ namespace Lsp.Protocol`
`7`	`8`	`{`
`8`	`9`	`public static class RegisterCapabilityExtensions`
`9`	`10`	`{`
`10`		`- public static Task RegisterCapability(this ILanguageServer mediator, RegistrationParams @params)`
	`11`	`+ public static async Task RegisterCapability(this ILanguageServer mediator, RegistrationParams @params)`
`11`	`12`	`{`
`12`		`- return mediator.SendRequest("client/registerCapability", @params);`
	`13`	`+ try`
	`14`	`+ {`
	`15`	`+ await mediator.SendRequest("client/registerCapability", @params);`
	`16`	`+ }`
	`17`	`+ catch (Exception e)`
	`18`	`+ {`
	`19`	`+ // VsCode today does not implement LSP properly.`
	`20`	`+ await mediator.SendRequest("client/registerFeature", @params);`
	`21`	`+ }`
`13`	`22`	`}`
`14`	`23`	`}`
`15`	`24`	`}`