Fix JsonSerializer eagerly resolving JsonTypeInfo for types with custom converters

Modified JsonPropertyInfo.Configure() to avoid eagerly resolving JsonTypeInfo when a custom converter is present, and updated JsonTypeInfo.Configure() to skip element/key type resolution for custom converters.

Co-authored-by: eiriktsarpalis <[email protected]>

Author: Copilot

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfo.cs

@@ -427,10 +427,24 @@ internal void Configure()
             }
             else
             {
-                _jsonTypeInfo ??= Options.GetTypeInfoInternal(PropertyType);
-                _jsonTypeInfo.EnsureConfigured();
+                // Try to expand any custom converter first to avoid
+                // eagerly resolving JsonTypeInfo for types that have custom converters.
+                // This prevents failures for types with properties that cannot be serialized
+                // (e.g., ref properties) when they have a custom converter that handles serialization.
+                JsonConverter? expandedCustomConverter = null;
+                if (CustomConverter is not null)
+                {
+                    expandedCustomConverter = Options.ExpandConverterFactory(CustomConverter, PropertyType);
+                }
+
+                if (expandedCustomConverter is null)
+                {
+                    // No custom converter or the factory returned null, so we need to get the JsonTypeInfo
+                    _jsonTypeInfo ??= Options.GetTypeInfoInternal(PropertyType);
+                    _jsonTypeInfo.EnsureConfigured();
+                }
 
-                DetermineEffectiveConverter(_jsonTypeInfo);
+                DetermineEffectiveConverter(_jsonTypeInfo, expandedCustomConverter);
                 DetermineNumberHandlingForProperty();
                 DetermineEffectiveObjectCreationHandlingForProperty();
                 DetermineSerializationCapabilities();
@@ -466,7 +480,7 @@ internal void Configure()
             IsConfigured = true;
         }
 
-        private protected abstract void DetermineEffectiveConverter(JsonTypeInfo jsonTypeInfo);
+        private protected abstract void DetermineEffectiveConverter(JsonTypeInfo? jsonTypeInfo, JsonConverter? expandedCustomConverter);
 
         [RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]
         [RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfoOfT.cs

@@ -144,14 +144,29 @@ internal override void AddJsonParameterInfo(JsonParameterInfoValues parameterInf
         internal override void DetermineReflectionPropertyAccessors(MemberInfo memberInfo, bool useNonPublicAccessors)
             => DefaultJsonTypeInfoResolver.DeterminePropertyAccessors<T>(this, memberInfo, useNonPublicAccessors);
 
-        private protected override void DetermineEffectiveConverter(JsonTypeInfo jsonTypeInfo)
+        private protected override void DetermineEffectiveConverter(JsonTypeInfo? jsonTypeInfo, JsonConverter? expandedCustomConverter)
         {
-            Debug.Assert(jsonTypeInfo is JsonTypeInfo<T>);
+            Debug.Assert(jsonTypeInfo is null or JsonTypeInfo<T>);
 
-            JsonConverter<T> converter =
-                Options.ExpandConverterFactory(CustomConverter, PropertyType) // Expand any property-level custom converters.
-                ?.CreateCastingConverter<T>()                                 // Cast to JsonConverter<T>, potentially with wrapping.
-                ?? ((JsonTypeInfo<T>)jsonTypeInfo).EffectiveConverter;        // Fall back to the effective converter for the type.
+            JsonConverter<T> converter;
+            if (expandedCustomConverter is not null)
+            {
+                // Use the already-expanded custom converter
+                converter = expandedCustomConverter.CreateCastingConverter<T>();
+            }
+            else
+            {
+                // Need to get JsonTypeInfo if we don't have it yet
+                if (jsonTypeInfo is null)
+                {
+                    jsonTypeInfo = Options.GetTypeInfoInternal(PropertyType);
+                    jsonTypeInfo.EnsureConfigured();
+                    JsonTypeInfo = jsonTypeInfo;
+                }
+
+                // Fall back to the effective converter for the type
+                converter = ((JsonTypeInfo<T>)jsonTypeInfo).EffectiveConverter;
+            }
 
             _effectiveConverter = converter;
             _typedEffectiveConverter = converter;

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonTypeInfo.cs

@@ -763,16 +763,21 @@ private void Configure()
                 }
             }
 
-            if (ElementType != null)
+            // Only resolve element and key types if using built-in converters.
+            // Custom converters should handle their element/key types themselves.
+            if (Converter.IsInternalConverter)
             {
-                _elementTypeInfo ??= Options.GetTypeInfoInternal(ElementType);
-                _elementTypeInfo.EnsureConfigured();
-            }
+                if (ElementType != null)
+                {
+                    _elementTypeInfo ??= Options.GetTypeInfoInternal(ElementType);
+                    _elementTypeInfo.EnsureConfigured();
+                }
 
-            if (KeyType != null)
-            {
-                _keyTypeInfo ??= Options.GetTypeInfoInternal(KeyType);
-                _keyTypeInfo.EnsureConfigured();
+                if (KeyType != null)
+                {
+                    _keyTypeInfo ??= Options.GetTypeInfoInternal(KeyType);
+                    _keyTypeInfo.EnsureConfigured();
+                }
             }
 
             DetermineIsCompatibleWithCurrentOptions();