Throw InvalidOperationException with contextual message for open generic converter on incompatible type

Copilot · eiriktsarpalis · Copilot · commit 5cffdfe4eade · 2026-03-19T08:52:06.000Z
Co-authored-by: eiriktsarpalis &lt;2813363+eiriktsarpalis@users.noreply.github.com&gt;
diff --git a/src/libraries/System.Text.Json/src/Resources/Strings.resx b/src/libraries/System.Text.Json/src/Resources/Strings.resx
@@ -411,6 +411,9 @@
   <data name="SerializationConverterOnAttributeNotCompatible" xml:space="preserve">
     <value>The converter specified on '{0}' is not compatible with the type '{1}'.</value>
   </data>
+  <data name="SerializationConverterOnAttributeOpenGenericNotCompatible" xml:space="preserve">
+    <value>The open generic converter type '{1}' specified on '{0}' cannot be instantiated because the target type is not a generic type with a matching number of type parameters.</value>
+  </data>
   <data name="SerializationConverterOnAttributeInvalid" xml:space="preserve">
     <value>The converter specified on '{0}' does not derive from JsonConverter or have a public parameterless constructor.</value>
   </data>
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/DefaultJsonTypeInfoResolver.Converters.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/DefaultJsonTypeInfoResolver.Converters.cs
@@ -192,11 +192,17 @@ private static JsonConverter GetConverterFromAttribute(JsonConverterAttribute co
                 // Handle open generic converter types (e.g., OptionConverter<> on Option<T>).
                 // If the converter type is an open generic and the type to convert is a closed generic
                 // with matching type arity, construct the closed converter type.
-                if (converterType.IsGenericTypeDefinition &&
-                    typeToConvert.IsGenericType &&
-                    converterType.GetGenericArguments().Length == typeToConvert.GetGenericArguments().Length)
+                if (converterType.IsGenericTypeDefinition)
                 {
-                    converterType = converterType.MakeGenericType(typeToConvert.GetGenericArguments());
+                    if (typeToConvert.IsGenericType &&
+                        converterType.GetGenericArguments().Length == typeToConvert.GetGenericArguments().Length)
+                    {
+                        converterType = converterType.MakeGenericType(typeToConvert.GetGenericArguments());
+                    }
+                    else
+                    {
+                        ThrowHelper.ThrowInvalidOperationException_SerializationConverterOnAttributeOpenGenericNotCompatible(declaringType, memberInfo, converterType);
+                    }
                 }
 
                 ConstructorInfo? ctor = converterType.GetConstructor(Type.EmptyTypes);
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs b/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs
@@ -229,6 +229,18 @@ public static void ThrowInvalidOperationException_SerializationConverterOnAttrib
             throw new InvalidOperationException(SR.Format(SR.SerializationConverterOnAttributeNotCompatible, location, typeToConvert));
         }
 
+        [DoesNotReturn]
+        public static void ThrowInvalidOperationException_SerializationConverterOnAttributeOpenGenericNotCompatible(Type classType, MemberInfo? memberInfo, Type converterType)
+        {
+            string location = classType.ToString();
+            if (memberInfo != null)
+            {
+                location += $".{memberInfo.Name}";
+            }
+
+            throw new InvalidOperationException(SR.Format(SR.SerializationConverterOnAttributeOpenGenericNotCompatible, location, converterType));
+        }
+
         [DoesNotReturn]
         public static void ThrowInvalidOperationException_SerializerOptionsReadOnly(JsonSerializerContext? context)
         {
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/CustomConverterTests/CustomConverterTests.Attribute.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/CustomConverterTests/CustomConverterTests.Attribute.cs
@@ -504,12 +504,12 @@ public override void Write(Utf8JsonWriter writer, MyGenericWrapper<T> value, Jso
 
         // Tests for type parameter arity mismatch
         [Fact]
-        public static void GenericConverterAttribute_ArityMismatch_ThrowsArgumentException()
+        public static void GenericConverterAttribute_ArityMismatch_ThrowsInvalidOperationException()
         {
-            // The converter has two type parameters but the type has one
-            // This throws ArgumentException because the arity doesn't match, so the converter type
-            // remains an unbound generic and Activator.CreateInstance fails.
-            Assert.Throws<ArgumentException>(() => JsonSerializer.Serialize(new TypeWithArityMismatch<int>()));
+            // The converter has two type parameters but the type has one.
+            // This throws InvalidOperationException with a contextual error message
+            // because the arity doesn't match.
+            Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(new TypeWithArityMismatch<int>()));
         }
 
         [JsonConverter(typeof(ConverterWithTwoParams<,>))]
@@ -580,12 +580,12 @@ public override void Write(Utf8JsonWriter writer, DifferentType<T> value, JsonSe
 
         // Tests for open generic converter on a non-generic type
         [Fact]
-        public static void GenericConverterAttribute_OpenGenericOnNonGenericType_ThrowsArgumentException()
+        public static void GenericConverterAttribute_OpenGenericOnNonGenericType_ThrowsInvalidOperationException()
         {
             // The converter is an open generic but the target type is not generic,
-            // so the converter type cannot be instantiated (Activator.CreateInstance fails
-            // because Type.ContainsGenericParameters is true).
-            Assert.Throws<ArgumentException>(() => JsonSerializer.Serialize(new NonGenericTypeWithOpenGenericConverter()));
+            // so the converter type cannot be instantiated. We throw InvalidOperationException
+            // with a contextual error message.
+            Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(new NonGenericTypeWithOpenGenericConverter()));
         }
 
         [JsonConverter(typeof(OpenGenericConverterForNonGenericType<>))]
