Merge pull request #38 from OmniSharp/fix/error

Breaking: Error object was misshaped, textdocumentsync double registered.
OmniSharp · Oct 19, 2017 · 3418b51 · 3418b51
2 parents 545fffb + f1c675a
commit 3418b51
Show file tree

Hide file tree

Showing 46 changed files with 422 additions and 208 deletions.
diff --git a/src/JsonRpc/Client/Response.cs b/src/JsonRpc/Client/Response.cs
@@ -1,13 +1,14 @@
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 
 namespace OmniSharp.Extensions.JsonRpc.Client
 {
     [JsonObject(NamingStrategyType = typeof(CamelCaseNamingStrategy))]
     public class Response
     {
-        public Response(object id) : this(id, null)
+        public Response(object id)
         {
+            Id = id;
         }
 
         public Response(object id, object result)
@@ -22,4 +23,4 @@ public Response(object id, object result)
 
         public object Result { get; set; }
     }
-}
+}
diff --git a/src/JsonRpc/Error.cs b/src/JsonRpc/Error.cs
diff --git a/src/JsonRpc/ErrorResponse.cs b/src/JsonRpc/ErrorResponse.cs
@@ -1,10 +1,10 @@
-using OmniSharp.Extensions.JsonRpc.Client;
+using OmniSharp.Extensions.JsonRpc.Client;
 
 namespace OmniSharp.Extensions.JsonRpc
 {
     public struct ErrorResponse
     {
-        public ErrorResponse(Error error)
+        public ErrorResponse(RpcError error)
         {
             Response = null;
             Error = error;
@@ -20,17 +20,17 @@ public ErrorResponse(Response response)
         public Response Response { get; }
 
         public bool IsError => Error != null;
-        public Error Error { get; }
+        public RpcError Error { get; }
         public object Value => IsResponse ? (object)Response : IsError ? Error : null;
 
         public static implicit operator ErrorResponse(Response response)
         {
             return new ErrorResponse(response);
         }
 
-        public static implicit operator ErrorResponse(Error error)
+        public static implicit operator ErrorResponse(RpcError error)
         {
             return new ErrorResponse(error);
         }
     }
-}
+}
diff --git a/src/JsonRpc/HandlerCollection.cs b/src/JsonRpc/HandlerCollection.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
@@ -66,16 +66,6 @@ public IDisposable Add(IJsonRpcHandler handler)
             return h;
         }
 
-        public IHandlerInstance Get(IJsonRpcHandler handler)
-        {
-            return _handlers.Find(instance => instance.Handler == handler);
-        }
-
-        public IHandlerInstance Get(string method)
-        {
-            return _handlers.Find(instance => instance.Method == method);
-        }
-
         private static readonly Type[] HandlerTypes = { typeof(INotificationHandler), typeof(INotificationHandler<>), typeof(IRequestHandler<>), typeof(IRequestHandler<,>), };
 
         private string GetMethodName(Type type)
@@ -115,4 +105,4 @@ private Type GetHandlerInterface(Type type)
                 .First(IsValidInterface);
         }
     }
-}
+}
diff --git a/src/JsonRpc/InputHandler.cs b/src/JsonRpc/InputHandler.cs
@@ -1,10 +1,12 @@
-using System;
+using System;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json.Linq;
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using OmniSharp.Extensions.JsonRpc.Server;
 using OmniSharp.Extensions.JsonRpc.Server.Messages;
 
 namespace OmniSharp.Extensions.JsonRpc
@@ -147,13 +149,13 @@ private void HandleRequest(string request)
                     var tcs = _responseRouter.GetRequest(id);
                     if (tcs is null) continue;
 
-                    if (response.Error is null)
+                    if (response is ServerResponse serverResponse)
                     {
-                        tcs.SetResult(response.Result);
+                        tcs.SetResult(serverResponse.Result);
                     }
-                    else
+                    else if (response is ServerError serverError)
                     {
-                        tcs.SetException(new Exception(response.Error));
+                        tcs.SetException(new Exception(JsonConvert.SerializeObject(serverError.Error)));
                     }
                 }
 
@@ -167,8 +169,7 @@ private void HandleRequest(string request)
                     _scheduler.Add(
                         type,
                         item.Request.Method,
-                        async () =>
-                        {
+                        async () => {
                             try
                             {
                                 var result = await _requestRouter.RouteRequest(item.Request);
@@ -189,8 +190,7 @@ private void HandleRequest(string request)
                     _scheduler.Add(
                         type,
                         item.Notification.Method,
-                        () =>
-                        {
+                        () => {
                             try
                             {
                                 _requestRouter.RouteNotification(item.Notification);

diff --git a/src/JsonRpc/Reciever.cs b/src/JsonRpc/Reciever.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using Newtonsoft.Json.Linq;
 using OmniSharp.Extensions.JsonRpc.Server;
@@ -63,12 +63,13 @@ protected virtual Renor GetRenor(JToken @object)
 
             if (hasRequestId && request.TryGetValue("result", out var response))
             {
-                return new Response(requestId, response);
+                return new ServerResponse(requestId, response);
             }
 
             if (hasRequestId && request.TryGetValue("error", out var errorResponse))
             {
-                return new Response(requestId, errorResponse.ToString());
+                // TODO: this doesn't seem right.
+                return new ServerError(requestId, errorResponse);
             }
 
             var method = request["method"]?.Value<string>();

diff --git a/src/JsonRpc/RequestRouter.cs b/src/JsonRpc/RequestRouter.cs
@@ -1,4 +1,5 @@
-using System;
+using System;
+using System.Linq;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
@@ -23,7 +24,7 @@ public IDisposable Add(IJsonRpcHandler handler)
 
         public async void RouteNotification(Notification notification)
         {
-            var handler = _collection.Get(notification.Method);
+            var handler = _collection.FirstOrDefault(x => x.Method == notification.Method);
 
             Task result;
             if (handler.Params is null)
@@ -46,16 +47,14 @@ public Task<ErrorResponse> RouteRequest(Request request)
 
         protected virtual async Task<ErrorResponse> RouteRequest(Request request, CancellationToken token)
         {
-            var handler = _collection.Get(request.Method);
-
-            var method = _collection.Get(request.Method);
-            if (method is null)
+            var handler = _collection.FirstOrDefault(x => x.Method == request.Method);
+            if (request.Method is null)
             {
-                return new MethodNotFound(request.Id);
+                return new MethodNotFound(request.Id, request.Method);
             }
 
             Task result;
-            if (method.Params is null)
+            if (handler.Params is null)
             {
                 result = ReflectionRequestHandlers.HandleRequest(handler, token);
             }
@@ -64,7 +63,7 @@ protected virtual async Task<ErrorResponse> RouteRequest(Request request, Cancel
                 object @params;
                 try
                 {
-                    @params = request.Params.ToObject(method.Params);
+                    @params = request.Params.ToObject(handler.Params);
                 }
                 catch
                 {
@@ -89,4 +88,4 @@ protected virtual async Task<ErrorResponse> RouteRequest(Request request, Cancel
             return new Client.Response(request.Id, responseValue);
         }
     }
-}
+}
diff --git a/src/JsonRpc/RpcError.cs b/src/JsonRpc/RpcError.cs
@@ -0,0 +1,42 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using OmniSharp.Extensions.JsonRpc.Server.Messages;
+
+namespace OmniSharp.Extensions.JsonRpc
+{
+
+    [JsonObject(NamingStrategyType = typeof(CamelCaseNamingStrategy)), JsonConverter(typeof(RpcErrorConverter))]
+    public class RpcError<T>
+    {
+        public RpcError(object id, ErrorMessage<T> message) : this(id, message, "2.0")
+        {
+        }
+
+        [JsonConstructor]
+        public RpcError(object id, ErrorMessage<T> message, string protocolVersion)
+        {
+            Id = id;
+            Error = message;
+            ProtocolVersion = protocolVersion;
+        }
+
+        public string ProtocolVersion { get; set; }
+
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public object Id { get; }
+
+        public ErrorMessage<T> Error { get; }
+    }
+
+    public class RpcError : RpcError<object>
+    {
+        public RpcError(object id, ErrorMessage<object> message) : this(id, message, "2.0")
+        {
+        }
+
+        [JsonConstructor]
+        public RpcError(object id, ErrorMessage<object> message, string protocolVersion) : base(id, message, protocolVersion)
+        {
+        }
+    }
+}
diff --git a/src/JsonRpc/RpcErrorConverter.cs b/src/JsonRpc/RpcErrorConverter.cs
@@ -0,0 +1,51 @@
+using System;
+using System.Reflection;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using OmniSharp.Extensions.JsonRpc.Server.Messages;
+
+namespace OmniSharp.Extensions.JsonRpc
+{
+    public class RpcErrorConverter : JsonConverter
+    {
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var obj = JObject.Load(reader);
+
+            var messageDataType = objectType == typeof(RpcError)
+                ? typeof(object)
+                : objectType.GetTypeInfo().GetGenericArguments()[0];
+
+            object requestId = null;
+            if (obj.TryGetValue("id", out var id))
+            {
+                var idString = id.Type == JTokenType.String ? (string)id : null;
+                var idLong = id.Type == JTokenType.Integer ? (long?)id : null;
+                requestId = idString ?? (idLong.HasValue ? (object)idLong.Value : null);
+            }
+
+            object data = null;
+            if (obj.TryGetValue("error", out var dataToken))
+            {
+                var errorMessageType = typeof(ErrorMessage<>).MakeGenericType(messageDataType);
+                data = dataToken.ToObject(errorMessageType);
+            }
+
+            return Activator.CreateInstance(objectType, requestId, data, obj["protocolVersion"].ToString());
+        }
+
+        public override bool CanConvert(Type objectType)
+        {
+            return objectType == typeof(RpcError) ||
+                   (objectType.GetTypeInfo().IsGenericType && objectType.GetTypeInfo().GetGenericTypeDefinition() == typeof(RpcError<>));
+        }
+
+        public override bool CanWrite { get; } = false;
+        public override bool CanRead { get; } = true;
+    }
+}