Mark JsonSerializerOptions.TypeInfoResolver as nullable and linker-safe (#72044)

* Mark JsonSerializerOptions.TypeInfoResolver as nullable and linker-safe

* Update src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/OptionsTests.cs

* Ensure TypeInfoResolver value is always populated in JsonSerializerOptions.Default

Author: eiriktsarpalis

src/libraries/System.Text.Json/ref/System.Text.Json.cs

@@ -339,7 +339,7 @@ public JsonSerializerOptions(System.Text.Json.JsonSerializerDefaults defaults) {
         public JsonSerializerOptions(System.Text.Json.JsonSerializerOptions options) { }
         public bool AllowTrailingCommas { get { throw null; } set { } }
         public System.Collections.Generic.IList<System.Text.Json.Serialization.JsonConverter> Converters { get { throw null; } }
-        public static System.Text.Json.JsonSerializerOptions Default { get { throw null; } }
+        public static System.Text.Json.JsonSerializerOptions Default { [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications."), System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] get { throw null; } }
         public int DefaultBufferSize { get { throw null; } set { } }
         public System.Text.Json.Serialization.JsonIgnoreCondition DefaultIgnoreCondition { get { throw null; } set { } }
         public System.Text.Json.JsonNamingPolicy? DictionaryKeyPolicy { get { throw null; } set { } }
@@ -356,16 +356,13 @@ public JsonSerializerOptions(System.Text.Json.JsonSerializerOptions options) { }
         public System.Text.Json.JsonNamingPolicy? PropertyNamingPolicy { get { throw null; } set { } }
         public System.Text.Json.JsonCommentHandling ReadCommentHandling { get { throw null; } set { } }
         public System.Text.Json.Serialization.ReferenceHandler? ReferenceHandler { get { throw null; } set { } }
-        [System.Diagnostics.CodeAnalysis.AllowNullAttribute]
-        public System.Text.Json.Serialization.Metadata.IJsonTypeInfoResolver TypeInfoResolver { [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications."), System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.")] get { throw null; } set { } }
+        public System.Text.Json.Serialization.Metadata.IJsonTypeInfoResolver? TypeInfoResolver { get { throw null; } set { } }
         public System.Text.Json.Serialization.JsonUnknownTypeHandling UnknownTypeHandling { get { throw null; } set { } }
         public bool WriteIndented { get { throw null; } set { } }
         public void AddContext<TContext>() where TContext : System.Text.Json.Serialization.JsonSerializerContext, new() { }
         [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Getting a converter for a type may require reflection which depends on runtime code generation.")]
         [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Getting a converter for a type may require reflection which depends on unreferenced code.")]
         public System.Text.Json.Serialization.JsonConverter GetConverter(System.Type typeToConvert) { throw null; }
-        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Getting a metadata for a type may require reflection which depends on unreferenced code.")]
-        [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Getting a metadata for a type may require reflection which depends on runtime code generation.")]
         public System.Text.Json.Serialization.Metadata.JsonTypeInfo GetTypeInfo(System.Type type) { throw null; }
     }
     public enum JsonTokenType : byte

src/libraries/System.Text.Json/src/Resources/Strings.resx

@@ -585,7 +585,7 @@
     <value>Built-in type converters have not been initialized. There is no converter available for type '{0}'. To root all built-in converters, use a 'JsonSerializerOptions'-based method of the 'JsonSerializer'.</value>
   </data>
   <data name="NoMetadataForType" xml:space="preserve">
-    <value>Metadata for type '{0}' was not provided to the serializer. The serializer method used does not support reflection-based creation of serialization-related type metadata. If using source generation, ensure that all root types passed to the serializer have been indicated with 'JsonSerializableAttribute', along with any types that might be serialized polymorphically.</value>
+    <value>Metadata for type '{0}' was not provided by TypeInfoResolver of type '{1}'. If using source generation, ensure that all root types passed to the serializer have been indicated with 'JsonSerializableAttribute', along with any types that might be serialized polymorphically.</value>
   </data>
   <data name="CollectionIsReadOnly" xml:space="preserve">
     <value>Collection is read-only.</value>

src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonArray.cs

@@ -165,7 +165,7 @@ public override void WriteTo(Utf8JsonWriter writer, JsonSerializerOptions? optio
                 CreateNodes();
                 Debug.Assert(_list != null);
 
-                options ??= JsonSerializerOptions.Default;
+                options ??= s_defaultOptions;
 
                 writer.WriteStartArray();
 

src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonNode.To.cs

@@ -5,6 +5,9 @@ namespace System.Text.Json.Nodes
 {
     public abstract partial class JsonNode
     {
+        // linker-safe default JsonSerializerOptions instance used by JsonNode methods.
+        private protected readonly JsonSerializerOptions s_defaultOptions = new();
+
         /// <summary>
         ///   Converts the current instance to string in JSON format.
         /// </summary>

src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonObject.cs

@@ -96,7 +96,7 @@ public override void WriteTo(Utf8JsonWriter writer, JsonSerializerOptions? optio
             }
             else
             {
-                options ??= JsonSerializerOptions.Default;
+                options ??= s_defaultOptions;
 
                 writer.WriteStartObject();
 

src/libraries/System.Text.Json/src/System/Text/Json/Nodes/JsonValueTrimmable.cs

@@ -34,7 +34,7 @@ public override void WriteTo(Utf8JsonWriter writer, JsonSerializerOptions? optio
 
             if (_converter != null)
             {
-                options ??= JsonSerializerOptions.Default;
+                options ??= s_defaultOptions;
 
                 if (_converter.IsInternalConverterForNumberType)
                 {

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Helpers.cs

@@ -20,7 +20,11 @@ private static JsonTypeInfo GetTypeInfo(JsonSerializerOptions? options, Type run
             Debug.Assert(runtimeType != null);
 
             options ??= JsonSerializerOptions.Default;
-            options.InitializeForReflectionSerializer();
+
+            if (!options.IsLockedInstance || !DefaultJsonTypeInfoResolver.IsDefaultInstanceRooted)
+            {
+                options.InitializeForReflectionSerializer();
+            }
 
             return options.GetTypeInfoForRootType(runtimeType);
         }
@@ -33,7 +37,7 @@ private static JsonTypeInfo GetTypeInfo(JsonSerializerContext context, Type type
             JsonTypeInfo? info = context.GetTypeInfo(type);
             if (info is null)
             {
-                ThrowHelper.ThrowInvalidOperationException_NoMetadataForType(type);
+                ThrowHelper.ThrowInvalidOperationException_NoMetadataForType(type, context);
             }
 
             return info;

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.Caching.cs

@@ -33,8 +33,6 @@ public sealed partial class JsonSerializerOptions
         ///
         /// If the <see cref="JsonSerializerOptions"/> instance is locked for modification, the method will return a cached instance for the metadata.
         /// </remarks>
-        [RequiresUnreferencedCode("Getting a metadata for a type may require reflection which depends on unreferenced code.")]
-        [RequiresDynamicCode("Getting a metadata for a type may require reflection which depends on runtime code generation.")]
         public JsonTypeInfo GetTypeInfo(Type type)
         {
             if (type is null)
@@ -47,8 +45,6 @@ public JsonTypeInfo GetTypeInfo(Type type)
                 ThrowHelper.ThrowArgumentException_CannotSerializeInvalidType(nameof(type), type, null, null);
             }
 
-            _typeInfoResolver ??= DefaultJsonTypeInfoResolver.RootDefaultInstance();
-
             JsonTypeInfo? typeInfo;
             if (IsLockedInstance)
             {
@@ -62,7 +58,7 @@ public JsonTypeInfo GetTypeInfo(Type type)
 
             if (typeInfo is null)
             {
-                ThrowHelper.ThrowNotSupportedException_NoMetadataForType(type);
+                ThrowHelper.ThrowNotSupportedException_NoMetadataForType(type, TypeInfoResolver);
             }
 
             return typeInfo;
@@ -82,7 +78,7 @@ internal JsonTypeInfo GetTypeInfoCached(Type type)
 
             if (typeInfo == null)
             {
-                ThrowHelper.ThrowNotSupportedException_NoMetadataForType(type);
+                ThrowHelper.ThrowNotSupportedException_NoMetadataForType(type, TypeInfoResolver);
                 return null;
             }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.Converters.cs

@@ -46,7 +46,13 @@ public JsonConverter GetConverter(Type typeToConvert)
                 ThrowHelper.ThrowArgumentNullException(nameof(typeToConvert));
             }
 
-            _typeInfoResolver ??= DefaultJsonTypeInfoResolver.RootDefaultInstance();
+            if (_typeInfoResolver is null)
+            {
+                // Backward compatibility -- root the default reflection converters
+                // but do not populate the TypeInfoResolver setting.
+                DefaultJsonTypeInfoResolver.RootDefaultInstance();
+            }
+
             return GetConverterFromTypeInfo(typeToConvert);
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializerOptions.cs

@@ -10,6 +10,7 @@
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
 using System.Text.Json.Serialization.Metadata;
+using System.Threading;
 
 namespace System.Text.Json
 {
@@ -32,7 +33,22 @@ public sealed partial class JsonSerializerOptions
         /// so using fresh default instances every time one is needed can result in redundant recomputation of converters.
         /// This property provides a shared instance that can be consumed by any number of components without necessitating any converter recomputation.
         /// </remarks>
-        public static JsonSerializerOptions Default { get; } = CreateDefaultImmutableInstance();
+        public static JsonSerializerOptions Default
+        {
+            [RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]
+            [RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
+            get
+            {
+                if (s_defaultOptions is not JsonSerializerOptions options)
+                {
+                    options = GetOrCreateDefaultOptionsInstance();
+                }
+
+                return options;
+            }
+        }
+
+        private static JsonSerializerOptions? s_defaultOptions;
 
         // For any new option added, adding it to the options copied in the copy constructor below must be considered.
         private IJsonTypeInfoResolver? _typeInfoResolver;
@@ -162,16 +178,15 @@ public JsonSerializerOptions(JsonSerializerDefaults defaults) : this()
         /// Gets or sets a <see cref="JsonTypeInfo"/> contract resolver.
         /// </summary>
         /// <remarks>
-        /// A <see langword="null"/> setting is equivalent to using the reflection-based <see cref="DefaultJsonTypeInfoResolver"/>.
+        /// When used with the reflection-based <see cref="JsonSerializer"/> APIs,
+        /// a <see langword="null"/> setting be equivalent to and replaced by the reflection-based
+        /// <see cref="DefaultJsonTypeInfoResolver"/>.
         /// </remarks>
-        [AllowNull]
-        public IJsonTypeInfoResolver TypeInfoResolver
+        public IJsonTypeInfoResolver? TypeInfoResolver
         {
-            [RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]
-            [RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
             get
             {
-                return _typeInfoResolver ??= DefaultJsonTypeInfoResolver.RootDefaultInstance();
+                return _typeInfoResolver;
             }
             set
             {
@@ -180,9 +195,6 @@ public IJsonTypeInfoResolver TypeInfoResolver
             }
         }
 
-        // Needed since public property is RequiresUnreferencedCode.
-        internal IJsonTypeInfoResolver? TypeInfoResolverSafe => _typeInfoResolver;
-
         /// <summary>
         /// Defines whether an extra comma at the end of a list of JSON values in an object or array
         /// is allowed (and ignored) within the JSON payload being deserialized.
@@ -598,6 +610,7 @@ internal bool IsLockedInstance
             set
             {
                 Debug.Assert(value, "cannot unlock options instances");
+                Debug.Assert(_typeInfoResolver != null, "cannot lock without a resolver.");
                 _isLockedInstance = true;
             }
         }
@@ -609,43 +622,22 @@ internal bool IsLockedInstance
         [RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
         internal void InitializeForReflectionSerializer()
         {
-            if (!_isInitializedForReflectionSerializer)
-            {
-                DefaultJsonTypeInfoResolver defaultResolver = DefaultJsonTypeInfoResolver.RootDefaultInstance();
-                _typeInfoResolver ??= defaultResolver;
-                IsLockedInstance = true;
-
-                CachingContext? context = GetCachingContext();
-                Debug.Assert(context != null);
-
-                if (context.Options != this)
-                {
-                    // We're using a shared caching context deriving from a different options instance;
-                    // for coherence ensure that it has been opted in for reflection-based serialization as well.
-                    context.Options.InitializeForReflectionSerializer();
-                }
-
-                _isInitializedForReflectionSerializer = true;
-            }
+            // Even if a resolver has already been specified, we need to root
+            // the default resolver to gain access to the default converters.
+            DefaultJsonTypeInfoResolver defaultResolver = DefaultJsonTypeInfoResolver.RootDefaultInstance();
+            _typeInfoResolver ??= defaultResolver;
+            IsLockedInstance = true;
         }
 
-        private volatile bool _isInitializedForReflectionSerializer;
-
         internal void InitializeForMetadataGeneration()
         {
-            if (!_isInitializedForMetadataGeneration)
+            if (_typeInfoResolver is null)
             {
-                if (_typeInfoResolver is null)
-                {
-                    ThrowHelper.ThrowInvalidOperationException_JsonTypeInfoUsedButTypeInfoResolverNotSet();
-                }
-
-                IsLockedInstance = true;
-                _isInitializedForMetadataGeneration = true;
+                ThrowHelper.ThrowInvalidOperationException_JsonTypeInfoUsedButTypeInfoResolverNotSet();
             }
-        }
 
-        private volatile bool _isInitializedForMetadataGeneration;
+            IsLockedInstance = true;
+        }
 
         private JsonTypeInfo? GetTypeInfoNoCaching(Type type)
         {
@@ -730,10 +722,17 @@ public ConverterList(JsonSerializerOptions options, IList<JsonConverter>? source
             protected override void VerifyMutable() => _options.VerifyMutable();
         }
 
-        private static JsonSerializerOptions CreateDefaultImmutableInstance()
+        [RequiresUnreferencedCode(JsonSerializer.SerializationUnreferencedCodeMessage)]
+        [RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)]
+        private static JsonSerializerOptions GetOrCreateDefaultOptionsInstance()
         {
-            var options = new JsonSerializerOptions { IsLockedInstance = true };
-            return options;
+            var options = new JsonSerializerOptions
+            {
+                TypeInfoResolver = DefaultJsonTypeInfoResolver.RootDefaultInstance(),
+                IsLockedInstance = true
+            };
+
+            return Interlocked.CompareExchange(ref s_defaultOptions, options, null) ?? options;
         }
     }
 }