dotnet: Fix issues with OrType serialization

generator-plugins/dotnet/custom/CustomObjectConverter.cs

@@ -0,0 +1,40 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+
+
+class CustomObjectConverter<T> : JsonConverter<T> where T : Dictionary<string, object?>
+{
+    public override T ReadJson(JsonReader reader, Type objectType, T? existingValue, bool hasExistingValue, JsonSerializer serializer)
+    {
+        if (reader.TokenType == JsonToken.Null)
+        {
+            return default(T);
+        }
+
+        Dictionary<string, object?>? o = serializer.Deserialize<Dictionary<string, object?>>(reader);
+        if (o == null)
+        {
+            return default(T);
+        }
+        return (T)Activator.CreateInstance(typeof(T), o) ?? default(T);
+    }
+
+    public override void WriteJson(JsonWriter writer, T? value, JsonSerializer serializer)
+    {
+        if (value is null)
+        {
+            writer.WriteNull();
+        }
+        else
+        {
+            writer.WriteStartObject();
+            foreach (var kvp in value)
+            {
+                writer.WritePropertyName(kvp.Key);
+                serializer.Serialize(writer, kvp.Value);
+            }
+            writer.WriteEndObject();
+        }
+    }
+}

generator-plugins/dotnet/custom/CustomStringConverter.cs

@@ -30,7 +30,7 @@ public override void WriteJson(JsonWriter writer, T? value, JsonSerializer seria
         }
         else if (value is T t)
         {
-            writer.WriteValue(t);
+            writer.WriteValue(t.ToString());
         }
         else
         {

generator-plugins/dotnet/custom/LSPAnyConverter.cs

@@ -0,0 +1,61 @@
+using Newtonsoft.Json;
+
+public class LSPAnyConverter : JsonConverter
+{
+    public override bool CanConvert(Type objectType)
+    {
+        return objectType == typeof(LSPAny);
+    }
+
+    public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
+    {
+        reader = reader ?? throw new ArgumentNullException(nameof(reader));
+        switch (reader.TokenType)
+        {
+            case JsonToken.Null:
+                return null;
+
+            case JsonToken.Integer:
+                return new LSPAny(serializer.Deserialize<long>(reader));
+
+            case JsonToken.Float:
+                return new LSPAny(serializer.Deserialize<float>(reader));
+
+            case JsonToken.Boolean:
+                return new LSPAny(serializer.Deserialize<bool>(reader));
+
+            case JsonToken.String:
+                return new LSPAny(serializer.Deserialize<string>(reader));
+
+            case JsonToken.StartArray:
+                List<object>? l = serializer.Deserialize<List<object>>(reader);
+                if (l == null)
+                {
+                    return null;
+                }
+                return new LSPAny(new LSPArray(l));
+
+            case JsonToken.StartObject:
+                Dictionary<string, object?>? o = serializer.Deserialize<Dictionary<string, object?>>(reader);
+                if (o == null)
+                {
+                    return null;
+                }
+                return new LSPAny(new LSPObject(o));
+        }
+
+        throw new JsonSerializationException($"Unexpected token type '{reader.TokenType}' while deserializing '{objectType.Name}'.");
+    }
+
+    public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
+    {
+        if (value is null)
+        {
+            writer.WriteNull();
+        }
+        else
+        {
+            serializer.Serialize(writer, ((LSPAny)value).Value);
+        }
+    }
+}

generator-plugins/dotnet/custom/OrTypeArrayConverter.cs

@@ -0,0 +1,143 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+
+
+public class OrTypeArrayConverter<T, U, V, W> : JsonConverter<OrType<T, U, V, W>[]>
+{
+    private OrTypeConverter<T, U, V, W> _converter;
+
+    public OrTypeArrayConverter()
+    {
+        _converter = new OrTypeConverter<T, U, V, W>();
+    }
+
+    public override OrType<T, U, V, W>[] ReadJson(JsonReader reader, Type objectType, OrType<T, U, V, W>[]? existingValue, bool hasExistingValue, JsonSerializer serializer)
+    {
+        if (reader.TokenType == JsonToken.Null)
+        {
+            return null;
+        }
+
+        JArray array = JArray.Load(reader);
+        var result = new OrType<T, U, V, W>[array.Count];
+
+        for (int i = 0; i < array.Count; i++)
+        {
+            result[i] = (OrType<T, U, V, W>)_converter.ReadJson(array[i].CreateReader(), typeof(OrType<T, U, V, W>), null, serializer);
+        }
+
+        return result;
+    }
+
+    public override void WriteJson(JsonWriter writer, OrType<T, U, V, W>[] value, JsonSerializer serializer)
+    {
+        if (value is null)
+        {
+            writer.WriteNull();
+        }
+        else
+        {
+            writer.WriteStartArray();
+
+            foreach (var item in value)
+            {
+                _converter.WriteJson(writer, item, serializer);
+            }
+
+            writer.WriteEndArray();
+        }
+    }
+}
+public class OrTypeArrayConverter<T, U> : JsonConverter<OrType<T, U>[]>
+{
+    private OrTypeConverter<T, U> _converter;
+
+    public OrTypeArrayConverter()
+    {
+        _converter = new OrTypeConverter<T, U>();
+    }
+
+    public override OrType<T, U>[] ReadJson(JsonReader reader, Type objectType, OrType<T, U>[]? existingValue, bool hasExistingValue, JsonSerializer serializer)
+    {
+        if (reader.TokenType == JsonToken.Null)
+        {
+            return null;
+        }
+
+        JArray array = JArray.Load(reader);
+        var result = new OrType<T, U>[array.Count];
+
+        for (int i = 0; i < array.Count; i++)
+        {
+            result[i] = (OrType<T, U>)_converter.ReadJson(array[i].CreateReader(), typeof(OrType<T, U>), null, serializer);
+        }
+
+        return result;
+    }
+
+    public override void WriteJson(JsonWriter writer, OrType<T, U>[] value, JsonSerializer serializer)
+    {
+        if (value is null)
+        {
+            writer.WriteNull();
+        }
+        else
+        {
+            writer.WriteStartArray();
+
+            foreach (var item in value)
+            {
+                _converter.WriteJson(writer, item, serializer);
+            }
+
+            writer.WriteEndArray();
+        }
+    }
+}
+public class OrTypeArrayConverter<T, U, V> : JsonConverter<OrType<T, U, V>[]>
+{
+    private OrTypeConverter<T, U, V> _converter;
+
+    public OrTypeArrayConverter()
+    {
+        _converter = new OrTypeConverter<T, U, V>();
+    }
+
+    public override OrType<T, U, V>[] ReadJson(JsonReader reader, Type objectType, OrType<T, U, V>[]? existingValue, bool hasExistingValue, JsonSerializer serializer)
+    {
+        if (reader.TokenType == JsonToken.Null)
+        {
+            return null;
+        }
+
+        JArray array = JArray.Load(reader);
+        var result = new OrType<T, U, V>[array.Count];
+
+        for (int i = 0; i < array.Count; i++)
+        {
+            result[i] = (OrType<T, U, V>)_converter.ReadJson(array[i].CreateReader(), typeof(OrType<T, U, V>), null, serializer);
+        }
+
+        return result;
+    }
+
+    public override void WriteJson(JsonWriter writer, OrType<T, U, V>[] value, JsonSerializer serializer)
+    {
+        if (value is null)
+        {
+            writer.WriteNull();
+        }
+        else
+        {
+            writer.WriteStartArray();
+
+            foreach (var item in value)
+            {
+                _converter.WriteJson(writer, item, serializer);
+            }
+
+            writer.WriteEndArray();
+        }
+    }
+}