Fixed error message not being formatted correctly

Author: david-driscoll

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)
@@ -16,10 +17,20 @@ public Response(object id, object result)
             Result = result;
         }
 
+        public Response(object id, RpcError result)
+        {
+            Id = id;
+            Result = result;
+        }
+
         public string ProtocolVersion { get; set; } = "2.0";
 
         public object Id { get; set; }
 
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
         public object Result { get; set; }
+
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public RpcError Error { get; set; }
     }
-}
+}

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);
         }
     }
-}
+}

src/JsonRpc/InputHandler.cs

@@ -1,10 +1,11 @@
-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.Messages;
 
 namespace OmniSharp.Extensions.JsonRpc
@@ -153,7 +154,7 @@ private void HandleRequest(string request)
                     }
                     else
                     {
-                        tcs.SetException(new Exception(response.Error));
+                        tcs.SetException(new Exception(JsonConvert.SerializeObject(response.Error)));
                     }
                 }
 

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;
@@ -68,7 +68,8 @@ protected virtual Renor GetRenor(JToken @object)
 
             if (hasRequestId && request.TryGetValue("error", out var errorResponse))
             {
-                return new Response(requestId, errorResponse.ToString());
+                // TODO: this doesn't seem right.
+                return new RpcError(requestId, new ErrorMessage<object>(-1337, "Unknown error response", errorResponse));
             }
 
             var method = request["method"]?.Value<string>();

src/JsonRpc/Error.cs src/JsonRpc/RpcError.cssrc/JsonRpc/Error.cs renamed to src/JsonRpc/RpcError.cs

@@ -1,22 +1,22 @@
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 using OmniSharp.Extensions.JsonRpc.Server.Messages;
 
 namespace OmniSharp.Extensions.JsonRpc
 {
 
-    [JsonObject(NamingStrategyType = typeof(CamelCaseNamingStrategy))]
-    public class Error<T>
+    [JsonObject(NamingStrategyType = typeof(CamelCaseNamingStrategy)), JsonConverter(typeof(RpcErrorConverter))]
+    public class RpcError<T>
     {
-        public Error(object id, ErrorMessage<T> message) : this(id, message, "2.0")
+        public RpcError(object id, ErrorMessage<T> message) : this(id, message, "2.0")
         {
         }
 
         [JsonConstructor]
-        public Error(object id, ErrorMessage<T> message, string protocolVersion)
+        public RpcError(object id, ErrorMessage<T> message, string protocolVersion)
         {
             Id = id;
-            Message = message;
+            Error = message;
             ProtocolVersion = protocolVersion;
         }
 
@@ -26,18 +26,18 @@ public Error(object id, ErrorMessage<T> message, string protocolVersion)
         public object Id { get; }
 
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
-        public ErrorMessage<T> Message { get; }
+        public ErrorMessage<T> Error { get; }
     }
 
-    public class Error : Error<object>
+    public class RpcError : RpcError<object>
     {
-        public Error(object id, ErrorMessage<object> message) : this(id, message, "2.0")
+        public RpcError(object id, ErrorMessage<object> message) : this(id, message, "2.0")
         {
         }
 
         [JsonConstructor]
-        public Error(object id, ErrorMessage<object> message, string protocolVersion) : base(id, message, protocolVersion)
+        public RpcError(object id, ErrorMessage<object> message, string protocolVersion) : base(id, message, protocolVersion)
         {
         }
     }
-}
+}

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;
+    }
+}

src/JsonRpc/Server/Messages/ErrorMessage.cs

@@ -3,20 +3,32 @@
 
 namespace OmniSharp.Extensions.JsonRpc.Server.Messages
 {
+    public interface IErrorMessage
+    {
+        int Code { get; }
+
+        string Message { get; }
+
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        object Data { get; }
+    }
+
     public class ErrorMessage: ErrorMessage<object>
     {
         public ErrorMessage(int code, string message) : base(code, message, null)
         {
         }
 
+        [JsonConstructor]
         public ErrorMessage(int code, string message, object data) : base(code, message, data)
         {
         }
     }
 
     [JsonObject(NamingStrategyType = typeof(CamelCaseNamingStrategy))]
-    public class ErrorMessage<T>
+    public class ErrorMessage<T> : IErrorMessage
     {
+        [JsonConstructor]
         public ErrorMessage(int code, string message, T data)
         {
             Code = code;
@@ -30,5 +42,7 @@ public ErrorMessage(int code, string message, T data)
 
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public T Data { get; }
+
+        object IErrorMessage.Data => Data;
     }
-}
+}

src/JsonRpc/Server/Messages/InternalError.cs

@@ -1,8 +1,8 @@
 namespace OmniSharp.Extensions.JsonRpc.Server.Messages
 {
-    public class InternalError : Error
+    public class InternalError : RpcError
     {
         public InternalError() : this(null) { }
         public InternalError(object id) : base(id, new ErrorMessage(-32602, "Internal Error")) { }
     }
-}
+}

src/JsonRpc/Server/Messages/InvalidParams.cs

@@ -1,8 +1,8 @@
 namespace OmniSharp.Extensions.JsonRpc.Server.Messages
 {
-    public class InvalidParams : Error
+    public class InvalidParams : RpcError
     {
         public InvalidParams() : this(null) { }
         public InvalidParams(object id) : base(id, new ErrorMessage(-32602, "Invalid params")) { }
     }
-}
+}

src/JsonRpc/Server/Messages/InvalidRequest.cs

@@ -1,11 +1,11 @@
 namespace OmniSharp.Extensions.JsonRpc.Server.Messages
 {
-    public class InvalidRequest : Error
+    public class InvalidRequest : RpcError
     {
 
         public InvalidRequest() : base(null, new ErrorMessage(-32600, $"Invalid Request")) { }
         public InvalidRequest(object id) : base(id, new ErrorMessage(-32600, $"Invalid Request")) { }
         public InvalidRequest(string message) : base(null, new ErrorMessage(-32600, $"Invalid Request - {message}")) { }
         public InvalidRequest(object id, string message) : base(id, new ErrorMessage(-32600, $"Invalid Request - {message}")) { }
     }
-}
+}