Merge in 'release/6.0' changes

dotnet-bot · dotnet-bot · commit 56c11f26e9c4 · 2022-01-10T23:37:37.000Z
diff --git a/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Emitter.cs b/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Emitter.cs
@@ -98,6 +98,9 @@ private sealed partial class Emitter
 
             private readonly HashSet<string> _emittedPropertyFileNames = new();
 
+            private bool _generateGetConverterMethodForTypes = false;
+            private bool _generateGetConverterMethodForProperties = false;
+
             public Emitter(in JsonSourceGenerationContext sourceGenerationContext, SourceGenerationSpec generationSpec)
             {
                 _sourceGenerationContext = sourceGenerationContext;
@@ -109,24 +112,20 @@ public void Emit()
                 foreach (ContextGenerationSpec contextGenerationSpec in _generationSpec.ContextGenerationSpecList)
                 {
                     _currentContext = contextGenerationSpec;
-
-                    bool generateGetConverterMethodForTypes = false;
-                    bool generateGetConverterMethodForProperties = false;
+                    _generateGetConverterMethodForTypes = false;
+                    _generateGetConverterMethodForProperties = false;
 
                     foreach (TypeGenerationSpec typeGenerationSpec in _currentContext.RootSerializableTypes)
                     {
                         GenerateTypeInfo(typeGenerationSpec);
-
-                        generateGetConverterMethodForTypes |= typeGenerationSpec.HasTypeFactoryConverter;
-                        generateGetConverterMethodForProperties |= typeGenerationSpec.HasPropertyFactoryConverters;
                     }
 
                     string contextName = _currentContext.ContextType.Name;
 
                     // Add root context implementation.
                     AddSource(
                         $"{contextName}.g.cs",
-                        GetRootJsonContextImplementation(generateGetConverterMethodForTypes, generateGetConverterMethodForProperties),
+                        GetRootJsonContextImplementation(),
                         isRootContextDef: true);
 
                     // Add GetJsonTypeInfo override implementation.
@@ -302,6 +301,9 @@ private void GenerateTypeInfo(TypeGenerationSpec typeGenerationSpec)
                     Location location = typeGenerationSpec.AttributeLocation ?? _currentContext.Location;
                     _sourceGenerationContext.ReportDiagnostic(Diagnostic.Create(DuplicateTypeName, location, new string[] { typeGenerationSpec.TypeInfoPropertyName }));
                 }
+
+                _generateGetConverterMethodForTypes |= typeGenerationSpec.HasTypeFactoryConverter;
+                _generateGetConverterMethodForProperties |= typeGenerationSpec.HasPropertyFactoryConverters;
             }
 
             private string GenerateForTypeWithKnownConverter(TypeGenerationSpec typeMetadata)
@@ -1145,9 +1147,7 @@ private string WrapWithCheckForCustomConverter(string source, string typeCompila
                 {IndentSource(source, numIndentations: 1)}
             }}";
 
-            private string GetRootJsonContextImplementation(
-                bool generateGetConverterMethodForTypes,
-                bool generateGetConverterMethodForProperties)
+            private string GetRootJsonContextImplementation()
             {
                 string contextTypeRef = _currentContext.ContextTypeRef;
                 string contextTypeName = _currentContext.ContextType.Name;
@@ -1171,12 +1171,12 @@ private string GetRootJsonContextImplementation(
 
 {GetFetchLogicForRuntimeSpecifiedCustomConverter()}");
 
-                if (generateGetConverterMethodForProperties)
+                if (_generateGetConverterMethodForProperties)
                 {
                     sb.Append(GetFetchLogicForGetCustomConverter_PropertiesWithFactories());
                 }
 
-                if (generateGetConverterMethodForProperties || generateGetConverterMethodForTypes)
+                if (_generateGetConverterMethodForProperties || _generateGetConverterMethodForTypes)
                 {
                     sb.Append(GetFetchLogicForGetCustomConverter_TypesWithFactories());
                 }
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/ContextClasses.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/ContextClasses.cs
@@ -42,8 +42,8 @@ public interface ITestContext
         public JsonTypeInfo<StructWithCustomConverterFactory> StructWithCustomConverterFactory { get; }
         public JsonTypeInfo<ClassWithCustomConverterProperty> ClassWithCustomConverterProperty { get; }
         public JsonTypeInfo<StructWithCustomConverterProperty> StructWithCustomConverterProperty { get; }
-        public JsonTypeInfo<ClassWithCustomConverterPropertyFactory> ClassWithCustomConverterPropertyFactory { get; }
-        public JsonTypeInfo<StructWithCustomConverterPropertyFactory> StructWithCustomConverterPropertyFactory { get; }
+        public JsonTypeInfo<ClassWithCustomConverterFactoryProperty> ClassWithCustomConverterFactoryProperty { get; }
+        public JsonTypeInfo<StructWithCustomConverterFactoryProperty> StructWithCustomConverterFactoryProperty { get; }
         public JsonTypeInfo<ClassWithBadCustomConverter> ClassWithBadCustomConverter { get; }
         public JsonTypeInfo<StructWithBadCustomConverter> StructWithBadCustomConverter { get; }
     }
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/JsonSerializerContextTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/JsonSerializerContextTests.cs
@@ -1,6 +1,7 @@
 ﻿// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Generic;
 using System.Reflection;
 using System.Text.Json.Serialization;
 using Microsoft.DotNet.RemoteExecutor;
@@ -89,5 +90,44 @@ internal record Person(string FirstName, string LastName);
         internal partial class PersonJsonContext : JsonSerializerContext
         {
         }
+
+        // Regression test for https://github.com/dotnet/runtime/issues/62079
+        [Fact]
+        public static void SupportsPropertiesWithCustomConverterFactory()
+        {
+            var value = new ClassWithCustomConverterFactoryProperty { MyEnum = Serialization.Tests.SampleEnum.MinZero };
+            string json = JsonSerializer.Serialize(value, SingleClassWithCustomConverterFactoryPropertyContext.Default.ClassWithCustomConverterFactoryProperty);
+            Assert.Equal(@"{""MyEnum"":""MinZero""}", json);
+        }
+
+        public class ParentClass
+        {
+            public ClassWithCustomConverterFactoryProperty? Child { get; set; }
+        }
+
+        [JsonSerializable(typeof(ParentClass))]
+        internal partial class SingleClassWithCustomConverterFactoryPropertyContext : JsonSerializerContext
+        {
+        }
+
+        // Regression test for https://github.com/dotnet/runtime/issues/61860
+        [Fact]
+        public static void SupportsGenericParameterWithCustomConverterFactory()
+        {
+            var value = new List<TestEnum> { TestEnum.Cee };
+            string json = JsonSerializer.Serialize(value, GenericParameterWithCustomConverterFactoryContext.Default.ListTestEnum);
+            Assert.Equal(@"[""Cee""]", json);
+        }
+
+        [JsonConverter(typeof(JsonStringEnumConverter))]
+        public enum TestEnum
+        {
+            Aye, Bee, Cee
+        }
+
+        [JsonSerializable(typeof(List<TestEnum>))]
+        internal partial class GenericParameterWithCustomConverterFactoryContext : JsonSerializerContext
+        {
+        }
     }
 }
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/MetadataAndSerializationContextTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/MetadataAndSerializationContextTests.cs
@@ -36,8 +36,8 @@ namespace System.Text.Json.SourceGeneration.Tests
     [JsonSerializable(typeof(StructWithCustomConverterFactory))]
     [JsonSerializable(typeof(ClassWithCustomConverterProperty))]
     [JsonSerializable(typeof(StructWithCustomConverterProperty))]
-    [JsonSerializable(typeof(ClassWithCustomConverterPropertyFactory))]
-    [JsonSerializable(typeof(StructWithCustomConverterPropertyFactory))]
+    [JsonSerializable(typeof(ClassWithCustomConverterFactoryProperty))]
+    [JsonSerializable(typeof(StructWithCustomConverterFactoryProperty))]
     [JsonSerializable(typeof(ClassWithBadCustomConverter))]
     [JsonSerializable(typeof(StructWithBadCustomConverter))]
     internal partial class MetadataAndSerializationContext : JsonSerializerContext, ITestContext
@@ -81,8 +81,8 @@ public override void EnsureFastPathGeneratedAsExpected()
             Assert.NotNull(MetadataAndSerializationContext.Default.StructWithCustomConverterFactory);
             Assert.NotNull(MetadataAndSerializationContext.Default.ClassWithCustomConverterProperty);
             Assert.NotNull(MetadataAndSerializationContext.Default.StructWithCustomConverterProperty);
-            Assert.NotNull(MetadataAndSerializationContext.Default.ClassWithCustomConverterPropertyFactory);
-            Assert.NotNull(MetadataAndSerializationContext.Default.StructWithCustomConverterPropertyFactory);
+            Assert.NotNull(MetadataAndSerializationContext.Default.ClassWithCustomConverterFactoryProperty);
+            Assert.NotNull(MetadataAndSerializationContext.Default.StructWithCustomConverterFactoryProperty);
             Assert.Throws<InvalidOperationException>(() => MetadataAndSerializationContext.Default.ClassWithBadCustomConverter);
             Assert.Throws<InvalidOperationException>(() => MetadataAndSerializationContext.Default.StructWithBadCustomConverter);
         }
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/MetadataContextTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/MetadataContextTests.cs
@@ -35,8 +35,8 @@ namespace System.Text.Json.SourceGeneration.Tests
     [JsonSerializable(typeof(StructWithCustomConverterFactory), GenerationMode = JsonSourceGenerationMode.Metadata)]
     [JsonSerializable(typeof(ClassWithCustomConverterProperty), GenerationMode = JsonSourceGenerationMode.Metadata)]
     [JsonSerializable(typeof(StructWithCustomConverterProperty), GenerationMode = JsonSourceGenerationMode.Metadata)]
-    [JsonSerializable(typeof(ClassWithCustomConverterPropertyFactory), GenerationMode = JsonSourceGenerationMode.Metadata)]
-    [JsonSerializable(typeof(StructWithCustomConverterPropertyFactory), GenerationMode = JsonSourceGenerationMode.Metadata)]
+    [JsonSerializable(typeof(ClassWithCustomConverterFactoryProperty), GenerationMode = JsonSourceGenerationMode.Metadata)]
+    [JsonSerializable(typeof(StructWithCustomConverterFactoryProperty), GenerationMode = JsonSourceGenerationMode.Metadata)]
     [JsonSerializable(typeof(ClassWithBadCustomConverter), GenerationMode = JsonSourceGenerationMode.Metadata)]
     [JsonSerializable(typeof(StructWithBadCustomConverter), GenerationMode = JsonSourceGenerationMode.Metadata)]
     internal partial class MetadataWithPerTypeAttributeContext : JsonSerializerContext, ITestContext
@@ -79,8 +79,8 @@ public override void EnsureFastPathGeneratedAsExpected()
             Assert.Null(MetadataWithPerTypeAttributeContext.Default.StructWithCustomConverterFactory.SerializeHandler);
             Assert.Null(MetadataWithPerTypeAttributeContext.Default.ClassWithCustomConverterProperty.SerializeHandler);
             Assert.Null(MetadataWithPerTypeAttributeContext.Default.StructWithCustomConverterProperty.SerializeHandler);
-            Assert.Null(MetadataWithPerTypeAttributeContext.Default.ClassWithCustomConverterPropertyFactory.SerializeHandler);
-            Assert.Null(MetadataWithPerTypeAttributeContext.Default.StructWithCustomConverterPropertyFactory.SerializeHandler);
+            Assert.Null(MetadataWithPerTypeAttributeContext.Default.ClassWithCustomConverterFactoryProperty.SerializeHandler);
+            Assert.Null(MetadataWithPerTypeAttributeContext.Default.StructWithCustomConverterFactoryProperty.SerializeHandler);
             Assert.Throws<InvalidOperationException>(() => MetadataWithPerTypeAttributeContext.Default.ClassWithBadCustomConverter.SerializeHandler);
             Assert.Throws<InvalidOperationException>(() => MetadataWithPerTypeAttributeContext.Default.StructWithBadCustomConverter.SerializeHandler);
         }
@@ -116,8 +116,8 @@ public override void EnsureFastPathGeneratedAsExpected()
     [JsonSerializable(typeof(StructWithCustomConverterFactory))]
     [JsonSerializable(typeof(ClassWithCustomConverterProperty))]
     [JsonSerializable(typeof(StructWithCustomConverterProperty))]
-    [JsonSerializable(typeof(ClassWithCustomConverterPropertyFactory))]
-    [JsonSerializable(typeof(StructWithCustomConverterPropertyFactory))]
+    [JsonSerializable(typeof(ClassWithCustomConverterFactoryProperty))]
+    [JsonSerializable(typeof(StructWithCustomConverterFactoryProperty))]
     [JsonSerializable(typeof(ClassWithBadCustomConverter))]
     [JsonSerializable(typeof(StructWithBadCustomConverter))]
     internal partial class MetadataContext : JsonSerializerContext, ITestContext
@@ -183,8 +183,8 @@ public override void EnsureFastPathGeneratedAsExpected()
             Assert.Null(MetadataContext.Default.StructWithCustomConverterFactory.SerializeHandler);
             Assert.Null(MetadataContext.Default.ClassWithCustomConverterProperty.SerializeHandler);
             Assert.Null(MetadataContext.Default.StructWithCustomConverterProperty.SerializeHandler);
-            Assert.Null(MetadataContext.Default.ClassWithCustomConverterPropertyFactory.SerializeHandler);
-            Assert.Null(MetadataContext.Default.StructWithCustomConverterPropertyFactory.SerializeHandler);
+            Assert.Null(MetadataContext.Default.ClassWithCustomConverterFactoryProperty.SerializeHandler);
+            Assert.Null(MetadataContext.Default.StructWithCustomConverterFactoryProperty.SerializeHandler);
             Assert.Throws<InvalidOperationException>(() => MetadataContext.Default.ClassWithBadCustomConverter.SerializeHandler);
             Assert.Throws<InvalidOperationException>(() => MetadataContext.Default.StructWithBadCustomConverter.SerializeHandler);
         }
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/MixedModeContextTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/MixedModeContextTests.cs
@@ -36,8 +36,8 @@ namespace System.Text.Json.SourceGeneration.Tests
     [JsonSerializable(typeof(StructWithCustomConverterFactory), GenerationMode = JsonSourceGenerationMode.Metadata | JsonSourceGenerationMode.Serialization)]
     [JsonSerializable(typeof(ClassWithCustomConverterProperty), GenerationMode = JsonSourceGenerationMode.Metadata | JsonSourceGenerationMode.Serialization)]
     [JsonSerializable(typeof(StructWithCustomConverterProperty), GenerationMode = JsonSourceGenerationMode.Metadata | JsonSourceGenerationMode.Serialization)]
-    [JsonSerializable(typeof(ClassWithCustomConverterPropertyFactory), GenerationMode = JsonSourceGenerationMode.Metadata | JsonSourceGenerationMode.Serialization)]
-    [JsonSerializable(typeof(StructWithCustomConverterPropertyFactory), GenerationMode = JsonSourceGenerationMode.Metadata | JsonSourceGenerationMode.Serialization)]
+    [JsonSerializable(typeof(ClassWithCustomConverterFactoryProperty), GenerationMode = JsonSourceGenerationMode.Metadata | JsonSourceGenerationMode.Serialization)]
+    [JsonSerializable(typeof(StructWithCustomConverterFactoryProperty), GenerationMode = JsonSourceGenerationMode.Metadata | JsonSourceGenerationMode.Serialization)]
     [JsonSerializable(typeof(ClassWithBadCustomConverter), GenerationMode = JsonSourceGenerationMode.Metadata | JsonSourceGenerationMode.Serialization)]
     [JsonSerializable(typeof(StructWithBadCustomConverter), GenerationMode = JsonSourceGenerationMode.Metadata | JsonSourceGenerationMode.Serialization)]
     internal partial class MixedModeContext : JsonSerializerContext, ITestContext
@@ -81,8 +81,8 @@ public override void EnsureFastPathGeneratedAsExpected()
             Assert.Null(MixedModeContext.Default.StructWithCustomConverterFactory.SerializeHandler);
             Assert.Null(MixedModeContext.Default.ClassWithCustomConverterProperty.SerializeHandler);
             Assert.Null(MixedModeContext.Default.StructWithCustomConverterProperty.SerializeHandler);
-            Assert.Null(MixedModeContext.Default.ClassWithCustomConverterPropertyFactory.SerializeHandler);
-            Assert.Null(MixedModeContext.Default.StructWithCustomConverterPropertyFactory.SerializeHandler);
+            Assert.Null(MixedModeContext.Default.ClassWithCustomConverterFactoryProperty.SerializeHandler);
+            Assert.Null(MixedModeContext.Default.StructWithCustomConverterFactoryProperty.SerializeHandler);
             Assert.Throws<InvalidOperationException>(() => MixedModeContext.Default.ClassWithBadCustomConverter.SerializeHandler);
             Assert.Throws<InvalidOperationException>(() => MixedModeContext.Default.StructWithBadCustomConverter.SerializeHandler);
         }
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/RealWorldContextTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/RealWorldContextTests.cs
@@ -246,28 +246,28 @@ public virtual void RoundTripWithCustomPropertyConverterFactory_Class()
         {
             const string Json = "{\"MyEnum\":\"One\"}";
 
-            ClassWithCustomConverterPropertyFactory obj = new()
+            ClassWithCustomConverterFactoryProperty obj = new()
             {
                 MyEnum = SampleEnum.One
             };
 
             if (DefaultContext.JsonSourceGenerationMode == JsonSourceGenerationMode.Serialization)
             {
-                Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterPropertyFactory));
+                Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterFactoryProperty));
             }
             else
             {
-                string json = JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterPropertyFactory);
+                string json = JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterFactoryProperty);
                 Assert.Equal(Json, json);
             }
 
             if (DefaultContext.JsonSourceGenerationMode == JsonSourceGenerationMode.Serialization)
             {
-                Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterPropertyFactory));
+                Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterFactoryProperty));
             }
             else
             {
-                obj = JsonSerializer.Deserialize(Json, DefaultContext.ClassWithCustomConverterPropertyFactory);
+                obj = JsonSerializer.Deserialize(Json, DefaultContext.ClassWithCustomConverterFactoryProperty);
                 Assert.Equal(SampleEnum.One, obj.MyEnum);
             }
         }
@@ -277,28 +277,28 @@ public virtual void RoundTripWithCustomPropertyConverterFactory_Struct()
         {
             const string Json = "{\"MyEnum\":\"One\"}";
 
-            StructWithCustomConverterPropertyFactory obj = new()
+            StructWithCustomConverterFactoryProperty obj = new()
             {
                 MyEnum = SampleEnum.One
             };
 
             if (DefaultContext.JsonSourceGenerationMode == JsonSourceGenerationMode.Serialization)
             {
-                Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterPropertyFactory));
+                Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterFactoryProperty));
             }
             else
             {
-                string json = JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterPropertyFactory);
+                string json = JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterFactoryProperty);
                 Assert.Equal(Json, json);
             }
 
             if (DefaultContext.JsonSourceGenerationMode == JsonSourceGenerationMode.Serialization)
             {
-                Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterPropertyFactory));
+                Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterFactoryProperty));
             }
             else
             {
-                obj = JsonSerializer.Deserialize(Json, DefaultContext.StructWithCustomConverterPropertyFactory);
+                obj = JsonSerializer.Deserialize(Json, DefaultContext.StructWithCustomConverterFactoryProperty);
                 Assert.Equal(SampleEnum.One, obj.MyEnum);
             }
         }
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/SerializationContextTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/SerializationContextTests.cs
diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/TestClasses.CustomConverters.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/TestClasses.CustomConverters.cs

Original file line number	Diff line number	Diff line change
`@@ -98,6 +98,9 @@ private sealed partial class Emitter`
`98`	`98`
`99`	`99`	`private readonly HashSet<string> _emittedPropertyFileNames = new();`
`100`	`100`
	`101`	`+ private bool _generateGetConverterMethodForTypes = false;`
	`102`	`+ private bool _generateGetConverterMethodForProperties = false;`
	`103`	`+`
`101`	`104`	`public Emitter(in JsonSourceGenerationContext sourceGenerationContext, SourceGenerationSpec generationSpec)`
`102`	`105`	`{`
`103`	`106`	`_sourceGenerationContext = sourceGenerationContext;`
`@@ -109,24 +112,20 @@ public void Emit()`
`109`	`112`	`foreach (ContextGenerationSpec contextGenerationSpec in _generationSpec.ContextGenerationSpecList)`
`110`	`113`	`{`
`111`	`114`	`_currentContext = contextGenerationSpec;`
`112`		`-`
`113`		`- bool generateGetConverterMethodForTypes = false;`
`114`		`- bool generateGetConverterMethodForProperties = false;`
	`115`	`+ _generateGetConverterMethodForTypes = false;`
	`116`	`+ _generateGetConverterMethodForProperties = false;`
`115`	`117`
`116`	`118`	`foreach (TypeGenerationSpec typeGenerationSpec in _currentContext.RootSerializableTypes)`
`117`	`119`	`{`
`118`	`120`	`GenerateTypeInfo(typeGenerationSpec);`
`119`		`-`
`120`		`- generateGetConverterMethodForTypes \|= typeGenerationSpec.HasTypeFactoryConverter;`
`121`		`- generateGetConverterMethodForProperties \|= typeGenerationSpec.HasPropertyFactoryConverters;`
`122`	`121`	`}`
`123`	`122`
`124`	`123`	`string contextName = _currentContext.ContextType.Name;`
`125`	`124`
`126`	`125`	`// Add root context implementation.`
`127`	`126`	`AddSource(`
`128`	`127`	`$"{contextName}.g.cs",`
`129`		`- GetRootJsonContextImplementation(generateGetConverterMethodForTypes, generateGetConverterMethodForProperties),`
	`128`	`+ GetRootJsonContextImplementation(),`
`130`	`129`	`isRootContextDef: true);`
`131`	`130`
`132`	`131`	`// Add GetJsonTypeInfo override implementation.`
`@@ -302,6 +301,9 @@ private void GenerateTypeInfo(TypeGenerationSpec typeGenerationSpec)`
`302`	`301`	`Location location = typeGenerationSpec.AttributeLocation ?? _currentContext.Location;`
`303`	`302`	`_sourceGenerationContext.ReportDiagnostic(Diagnostic.Create(DuplicateTypeName, location, new string[] { typeGenerationSpec.TypeInfoPropertyName }));`
`304`	`303`	`}`
	`304`	`+`
	`305`	`+ _generateGetConverterMethodForTypes \|= typeGenerationSpec.HasTypeFactoryConverter;`
	`306`	`+ _generateGetConverterMethodForProperties \|= typeGenerationSpec.HasPropertyFactoryConverters;`
`305`	`307`	`}`
`306`	`308`
`307`	`309`	`private string GenerateForTypeWithKnownConverter(TypeGenerationSpec typeMetadata)`
`@@ -1145,9 +1147,7 @@ private string WrapWithCheckForCustomConverter(string source, string typeCompila`
`1145`	`1147`	`{IndentSource(source, numIndentations: 1)}`
`1146`	`1148`	`}}";`
`1147`	`1149`
`1148`		`- private string GetRootJsonContextImplementation(`
`1149`		`- bool generateGetConverterMethodForTypes,`
`1150`		`- bool generateGetConverterMethodForProperties)`
	`1150`	`+ private string GetRootJsonContextImplementation()`
`1151`	`1151`	`{`
`1152`	`1152`	`string contextTypeRef = _currentContext.ContextTypeRef;`
`1153`	`1153`	`string contextTypeName = _currentContext.ContextType.Name;`
`@@ -1171,12 +1171,12 @@ private string GetRootJsonContextImplementation(`
`1171`	`1171`
`1172`	`1172`	`{GetFetchLogicForRuntimeSpecifiedCustomConverter()}");`
`1173`	`1173`
`1174`		`- if (generateGetConverterMethodForProperties)`
	`1174`	`+ if (_generateGetConverterMethodForProperties)`
`1175`	`1175`	`{`
`1176`	`1176`	`sb.Append(GetFetchLogicForGetCustomConverter_PropertiesWithFactories());`
`1177`	`1177`	`}`
`1178`	`1178`
`1179`		`- if (generateGetConverterMethodForProperties \|\| generateGetConverterMethodForTypes)`
	`1179`	`+ if (_generateGetConverterMethodForProperties \|\| _generateGetConverterMethodForTypes)`
`1180`	`1180`	`{`
`1181`	`1181`	`sb.Append(GetFetchLogicForGetCustomConverter_TypesWithFactories());`
`1182`	`1182`	`}`
Original file line number	Diff line number	Diff line change
`@@ -246,28 +246,28 @@ public virtual void RoundTripWithCustomPropertyConverterFactory_Class()`
`246`	`246`	`{`
`247`	`247`	`const string Json = "{\"MyEnum\":\"One\"}";`
`248`	`248`
`249`		`- ClassWithCustomConverterPropertyFactory obj = new()`
	`249`	`+ ClassWithCustomConverterFactoryProperty obj = new()`
`250`	`250`	`{`
`251`	`251`	`MyEnum = SampleEnum.One`
`252`	`252`	`};`
`253`	`253`
`254`	`254`	`if (DefaultContext.JsonSourceGenerationMode == JsonSourceGenerationMode.Serialization)`
`255`	`255`	`{`
`256`		`- Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterPropertyFactory));`
	`256`	`+ Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterFactoryProperty));`
`257`	`257`	`}`
`258`	`258`	`else`
`259`	`259`	`{`
`260`		`- string json = JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterPropertyFactory);`
	`260`	`+ string json = JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterFactoryProperty);`
`261`	`261`	`Assert.Equal(Json, json);`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`if (DefaultContext.JsonSourceGenerationMode == JsonSourceGenerationMode.Serialization)`
`265`	`265`	`{`
`266`		`- Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterPropertyFactory));`
	`266`	`+ Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.ClassWithCustomConverterFactoryProperty));`
`267`	`267`	`}`
`268`	`268`	`else`
`269`	`269`	`{`
`270`		`- obj = JsonSerializer.Deserialize(Json, DefaultContext.ClassWithCustomConverterPropertyFactory);`
	`270`	`+ obj = JsonSerializer.Deserialize(Json, DefaultContext.ClassWithCustomConverterFactoryProperty);`
`271`	`271`	`Assert.Equal(SampleEnum.One, obj.MyEnum);`
`272`	`272`	`}`
`273`	`273`	`}`
`@@ -277,28 +277,28 @@ public virtual void RoundTripWithCustomPropertyConverterFactory_Struct()`
`277`	`277`	`{`
`278`	`278`	`const string Json = "{\"MyEnum\":\"One\"}";`
`279`	`279`
`280`		`- StructWithCustomConverterPropertyFactory obj = new()`
	`280`	`+ StructWithCustomConverterFactoryProperty obj = new()`
`281`	`281`	`{`
`282`	`282`	`MyEnum = SampleEnum.One`
`283`	`283`	`};`
`284`	`284`
`285`	`285`	`if (DefaultContext.JsonSourceGenerationMode == JsonSourceGenerationMode.Serialization)`
`286`	`286`	`{`
`287`		`- Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterPropertyFactory));`
	`287`	`+ Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterFactoryProperty));`
`288`	`288`	`}`
`289`	`289`	`else`
`290`	`290`	`{`
`291`		`- string json = JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterPropertyFactory);`
	`291`	`+ string json = JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterFactoryProperty);`
`292`	`292`	`Assert.Equal(Json, json);`
`293`	`293`	`}`
`294`	`294`
`295`	`295`	`if (DefaultContext.JsonSourceGenerationMode == JsonSourceGenerationMode.Serialization)`
`296`	`296`	`{`
`297`		`- Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterPropertyFactory));`
	`297`	`+ Assert.Throws<InvalidOperationException>(() => JsonSerializer.Serialize(obj, DefaultContext.StructWithCustomConverterFactoryProperty));`
`298`	`298`	`}`
`299`	`299`	`else`
`300`	`300`	`{`
`301`		`- obj = JsonSerializer.Deserialize(Json, DefaultContext.StructWithCustomConverterPropertyFactory);`
	`301`	`+ obj = JsonSerializer.Deserialize(Json, DefaultContext.StructWithCustomConverterFactoryProperty);`
`302`	`302`	`Assert.Equal(SampleEnum.One, obj.MyEnum);`
`303`	`303`	`}`
`304`	`304`	`}`