refactor(UnionJsonConverter): Simplify JSON deserialization logic and error handling

Author: Yushu2606

src/Utils/Union.cs

@@ -1,4 +1,5 @@
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
 
 namespace Limekuma.Utils;
@@ -83,31 +84,24 @@ private class UnionJsonConverterInner<TA, TB> : JsonConverter<Union<TA, TB>>
         public override Union<TA, TB> Read(ref Utf8JsonReader reader, Type typeToConvert,
             JsonSerializerOptions options)
         {
-            try
-            {
-                TA? valueA = JsonSerializer.Deserialize<TA>(ref reader, options);
-                return new(valueA);
-            }
-            catch (JsonException)
-            {
-            }
-            catch (InvalidOperationException)
+            using JsonDocument doc = JsonDocument.ParseValue(ref reader);
+            JsonElement element = doc.RootElement;
+            if (element.ValueKind is JsonValueKind.Null)
             {
+                return new(null);
             }
 
-            try
+            bool preferA = ShouldChooseA(typeof(TA), typeof(TB), element.ValueKind);
+            if (preferA)
             {
-                TB? valueB = JsonSerializer.Deserialize<TB>(ref reader, options);
-                return new(valueB);
+                TA? a = element.Deserialize<TA>(options);
+                return new(a);
             }
-            catch (JsonException)
+            else
             {
+                TB? b = element.Deserialize<TB>(options);
+                return new(b);
             }
-            catch (InvalidOperationException)
-            {
-            }
-
-            return new(null);
         }
 
         public override void Write(Utf8JsonWriter writer, Union<TA, TB> value, JsonSerializerOptions options)
@@ -120,5 +114,123 @@ public override void Write(Utf8JsonWriter writer, Union<TA, TB> value, JsonSeria
 
             JsonSerializer.Serialize(writer, value.Value, options);
         }
+
+        private static bool ShouldChooseA(Type ta, Type tb, JsonValueKind kind)
+        {
+            ta = UnwrapNullable(ta);
+            tb = UnwrapNullable(tb);
+            switch (kind)
+            {
+                case JsonValueKind.String:
+                    {
+                        bool taMatch = IsStringLike(ta);
+                        bool tbMatch = IsStringLike(tb);
+                        return taMatch switch
+                        {
+                            true when !tbMatch => true,
+                            false when tbMatch => false,
+                            _ => true
+                        };
+                    }
+                case JsonValueKind.Number:
+                    {
+                        bool taMatch = IsNumericLike(ta) || ta.IsEnum;
+                        bool tbMatch = IsNumericLike(tb) || tb.IsEnum;
+                        return taMatch switch
+                        {
+                            true when !tbMatch => true,
+                            false when tbMatch => false,
+                            _ => true
+                        };
+                    }
+                case JsonValueKind.True:
+                case JsonValueKind.False:
+                    {
+                        bool taMatch = IsBooleanLike(ta);
+                        bool tbMatch = IsBooleanLike(tb);
+                        return taMatch switch
+                        {
+                            true when !tbMatch => true,
+                            false when tbMatch => false,
+                            _ => true
+                        };
+                    }
+                case JsonValueKind.Array:
+                    {
+                        bool taMatch = IsArrayLike(ta);
+                        bool tbMatch = IsArrayLike(tb);
+                        if (taMatch && !tbMatch) return true;
+                        if (!taMatch && tbMatch) return false;
+                        return true;
+                    }
+                case JsonValueKind.Object:
+                    {
+                        bool taMatch = IsObjectLike(ta);
+                        bool tbMatch = IsObjectLike(tb);
+                        if (taMatch && !tbMatch) return true;
+                        if (!taMatch && tbMatch) return false;
+                        return true;
+                    }
+                case JsonValueKind.Undefined:
+                case JsonValueKind.Null:
+                default:
+                    return true;
+            }
+        }
+
+        private static Type UnwrapNullable(Type t) => Nullable.GetUnderlyingType(t) ?? t;
+
+        private static bool IsStringLike(Type t)
+        {
+            if (t == typeof(string)) return true;
+            if (t == typeof(Guid)) return true;
+            if (t == typeof(DateTime)) return true;
+            if (t == typeof(DateTimeOffset)) return true;
+            if (t.FullName is "System.DateOnly") return true;
+            if (t.FullName is "System.TimeOnly") return true;
+            if (t == typeof(Uri)) return true;
+            return false;
+        }
+
+        private static bool IsNumericLike(Type t)
+        {
+            TypeCode code = Type.GetTypeCode(t);
+            return code switch
+            {
+                TypeCode.Byte or TypeCode.SByte or TypeCode.Int16 or TypeCode.UInt16 or TypeCode.Int32 or TypeCode.UInt32 or TypeCode.Int64 or TypeCode.UInt64 or TypeCode.Single or TypeCode.Double or TypeCode.Decimal => true,
+                _ => false,
+            };
+        }
+
+        private static bool IsBooleanLike(Type t) => t == typeof(bool);
+
+        private static bool IsArrayLike(Type t)
+        {
+            if (t == typeof(string)) return false;
+            if (t.IsArray) return true;
+            if (typeof(System.Collections.IDictionary).IsAssignableFrom(t)) return false;
+            foreach (Type i in t.GetInterfaces())
+            {
+                switch (i.IsGenericType)
+                {
+                    case true when i.GetGenericTypeDefinition() == typeof(IDictionary<,>):
+                        return false;
+                    case true when i.GetGenericTypeDefinition() == typeof(IEnumerable<>):
+                        return true;
+                }
+            }
+
+            return typeof(System.Collections.IEnumerable).IsAssignableFrom(t) &&
+                   !typeof(System.Collections.IDictionary).IsAssignableFrom(t);
+        }
+
+        private static bool IsObjectLike(Type t)
+        {
+            if (IsStringLike(t)) return false;
+            if (IsNumericLike(t) || t.IsEnum) return false;
+            if (IsBooleanLike(t)) return false;
+            if (IsArrayLike(t)) return false;
+            return true;
+        }
     }
-}
+}