move System.Object serialization to ObjectConverter

Author: eiriktsarpalis

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/ObjectConverter.cs

@@ -24,7 +24,10 @@ public ObjectConverter()
 
         public override void Write(Utf8JsonWriter writer, object? value, JsonSerializerOptions options)
         {
-            throw new InvalidOperationException();
+            Debug.Assert(value?.GetType() == typeof(object));
+
+            writer.WriteStartObject();
+            writer.WriteEndObject();
         }
 
         internal override object ReadWithQuotes(ref Utf8JsonReader reader)

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

@@ -349,28 +349,14 @@ internal bool TryWrite(Utf8JsonWriter writer, in T value, JsonSerializerOptions
                     ignoreCyclesPopReference = true;
                 }
 
-                if (state.NextValueCanBePolymorphic ||
-                    // only needed to handle the corner case of root-level values of runtime type `System.Object`
-                    // TODO: delegate `System.Object` runtime type serialization to ObjectConverter.
-                    TypeToConvert == JsonTypeInfo.ObjectType)
+                if (state.NextValueCanBePolymorphic)
                 {
-                    Debug.Assert(ConverterStrategy != ConverterStrategy.Value || TypeToConvert == JsonTypeInfo.ObjectType);
+                    Debug.Assert(IsInternalConverter);
+                    Debug.Assert(ConverterStrategy != ConverterStrategy.Value || this is Converters.ObjectConverter);
 
                     Type type = value.GetType();
-                    if (type == JsonTypeInfo.ObjectType)
-                    {
-                        writer.WriteStartObject();
-                        writer.WriteEndObject();
-
-                        if (ignoreCyclesPopReference)
-                        {
-                            state.ReferenceResolver.PopReferenceForCycleDetection();
-                        }
 
-                        return true;
-                    }
-
-                    if (type != TypeToConvert && IsInternalConverter)
+                    if (type != TypeToConvert)
                     {
                         // For internal converter only: Handle polymorphic case and get the new converter.
                         // Custom converter, even though polymorphic converter, get called for reading AND writing.
@@ -408,6 +394,15 @@ internal bool TryWrite(Utf8JsonWriter writer, in T value, JsonSerializerOptions
                 }
 
                 VerifyWrite(originalPropertyDepth, writer);
+
+                if (ignoreCyclesPopReference)
+                {
+                    // should only be entered if we're serializing with the
+                    // internal object converter handling values of runtime type object.
+                    Debug.Assert(value?.GetType() == typeof(object) && this is Converters.ObjectConverter);
+                    state.ReferenceResolver.PopReferenceForCycleDetection();
+                }
+
                 return true;
             }
 

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

@@ -551,8 +551,9 @@ private void InitializePolymorphismConfiguration(ConverterStrategy converterStra
 
             // Resolve polymorphic serialization configuration
             CanBeWritePolymorphic =
+                isInternalConverter && !Type.IsValueType && !Type.IsSealed &&
                 Type == JsonTypeInfo.ObjectType ||
-                !Type.IsValueType && !Type.IsSealed && converterStrategy != ConverterStrategy.Value &&
+                converterStrategy != ConverterStrategy.Value &&
                     (Options?.SupportedPolymorphicTypes(Type) == true ||
                      Type.GetCustomAttribute<JsonPolymorphicTypeAttribute>(inherit: false) is not null);
 

src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/CustomConverterTests/CustomConverterTests.Object.cs

@@ -307,7 +307,9 @@ public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonS
 
             public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
             {
-                throw new InvalidOperationException("Should not get here.");
+                Assert.IsType<object>(value);
+                writer.WriteStartObject();
+                writer.WriteEndObject();
             }
         }
 
@@ -732,5 +734,34 @@ static void Verify(JsonSerializerOptions options)
             options.Converters.Add(new SystemObjectNewtonsoftCompatibleConverter());
             Verify(options);
         }
+
+        [Fact]
+        public static void CanCustomizeSystemObjectSerialization()
+        {
+            var options = new JsonSerializerOptions { Converters = { new CustomSystemObjectConverter() } };
+
+            string expectedJson = "\"Object\"";
+            string actualJson = JsonSerializer.Serialize(new object(), options);
+            Assert.Equal(expectedJson, actualJson);
+        }
+
+        private class CustomSystemObjectConverter : JsonConverter<object>
+        {
+            public override object? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => throw new NotImplementedException();
+            public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
+            {
+                if (value?.GetType() == typeof(object))
+                {
+                    // check that serialization for values of
+                    // runtime type object can be customized.
+                    writer.WriteStringValue("Object");
+                }
+                else
+                {
+                    throw new NotSupportedException();
+                }
+            }
+        }
     }
+
 }

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

@@ -328,12 +328,12 @@ public static void JsonEncodedTextStringsCustomAllowAll(string message, string e
         [Fact]
         public static void Options_GetConverterForObjectJsonElement_GivesCorrectConverter()
         {
-            GenericObjectOrJsonElementConverterTestHelper<object>("ObjectConverter", new object(), "[3]", true);
+            GenericObjectOrJsonElementConverterTestHelper<object>("ObjectConverter", new object(), "{}");
             JsonElement element = JsonDocument.Parse("[3]").RootElement;
-            GenericObjectOrJsonElementConverterTestHelper<JsonElement>("JsonElementConverter", element, "[3]", false);
+            GenericObjectOrJsonElementConverterTestHelper<JsonElement>("JsonElementConverter", element, "[3]");
         }
 
-        private static void GenericObjectOrJsonElementConverterTestHelper<T>(string converterName, object objectValue, string stringValue, bool throws)
+        private static void GenericObjectOrJsonElementConverterTestHelper<T>(string converterName, object objectValue, string stringValue)
         {
             var options = new JsonSerializerOptions();
 
@@ -347,10 +347,7 @@ private static void GenericObjectOrJsonElementConverterTestHelper<T>(string conv
 
             if (readValue is JsonElement element)
             {
-                Assert.Equal(JsonValueKind.Array, element.ValueKind);
-                JsonElement.ArrayEnumerator iterator = element.EnumerateArray();
-                Assert.True(iterator.MoveNext());
-                Assert.Equal(3, iterator.Current.GetInt32());
+                JsonTestHelper.AssertJsonEqual(stringValue, element.ToString());
             }
             else
             {
@@ -360,22 +357,14 @@ private static void GenericObjectOrJsonElementConverterTestHelper<T>(string conv
             using (var stream = new MemoryStream())
             using (var writer = new Utf8JsonWriter(stream))
             {
-                if (throws)
-                {
-                    Assert.Throws<InvalidOperationException>(() => converter.Write(writer, (T)objectValue, options));
-                    Assert.Throws<InvalidOperationException>(() => converter.Write(writer, (T)objectValue, null));
-                }
-                else
-                {
-                    converter.Write(writer, (T)objectValue, options);
-                    writer.Flush();
-                    Assert.Equal(stringValue, Encoding.UTF8.GetString(stream.ToArray()));
-
-                    writer.Reset(stream);
-                    converter.Write(writer, (T)objectValue, null); // Test with null option
-                    writer.Flush();
-                    Assert.Equal(stringValue + stringValue, Encoding.UTF8.GetString(stream.ToArray()));
-                }
+                converter.Write(writer, (T)objectValue, options);
+                writer.Flush();
+                Assert.Equal(stringValue, Encoding.UTF8.GetString(stream.ToArray()));
+
+                writer.Reset(stream);
+                converter.Write(writer, (T)objectValue, null); // Test with null option
+                writer.Flush();
+                Assert.Equal(stringValue + stringValue, Encoding.UTF8.GetString(stream.ToArray()));
             }
         }