Add IReadOnlySet support to System.Text.Json

src/libraries/System.Text.Json/gen/Helpers/KnownTypeSymbols.cs

@@ -52,6 +52,12 @@ public KnownTypeSymbols(Compilation compilation)
         public INamedTypeSymbol? ISetOfTType => GetOrResolveType(typeof(ISet<>), ref _ISetOfTType);
         private Option<INamedTypeSymbol?> _ISetOfTType;
 
+        // Only modern .NET (> 5.0) supports IReadOnlySet<T>.
+#if NET
+        public INamedTypeSymbol? IReadOnlySetOfTType => GetOrResolveType(typeof(IReadOnlySet<>), ref _IReadOnlySetOfTType);
+        private Option<INamedTypeSymbol?> _IReadOnlySetOfTType;
+#endif
+
         public INamedTypeSymbol? StackOfTType => GetOrResolveType(typeof(Stack<>), ref _StackOfTType);
         private Option<INamedTypeSymbol?> _StackOfTType;
 

src/libraries/System.Text.Json/gen/JsonSourceGenerator.Emitter.cs

@@ -1515,6 +1515,11 @@ private static string GetCollectionInfoMethodName(CollectionType collectionType)
                     CollectionType.ReadOnlyMemoryOfT => "CreateReadOnlyMemoryInfo",
                     CollectionType.ISet => "CreateISetInfo",
 
+                    // Only modern .NET (> 5.0) supports IReadOnlySet<T>.
+#if NET
+        CollectionType.IReadOnlySetOfT => "CreateIReadOnlySetInfo",
+#endif
+
                     CollectionType.Dictionary => "CreateDictionaryInfo",
                     CollectionType.IDictionaryOfTKeyTValue or CollectionType.IDictionary => "CreateIDictionaryInfo",
                     CollectionType.IReadOnlyDictionary => "CreateIReadOnlyDictionaryInfo",

src/libraries/System.Text.Json/gen/JsonSourceGenerator.Parser.cs

@@ -846,6 +846,14 @@ private bool TryResolveCollectionType(
                     collectionType = CollectionType.ISet;
                     valueType = actualTypeToConvert.TypeArguments[0];
                 }
+                // Only modern .NET (> 5.0) supports IReadOnlySet<T>.
+#if NET
+                else if ((actualTypeToConvert = type.GetCompatibleGenericBaseType(_knownSymbols.IReadOnlySetOfTType)) != null)
+                {
+                    collectionType = CollectionType.IReadOnlySetOfT;
+                    valueType = actualTypeToConvert.TypeArguments[0];
+                }
+#endif
                 else if ((actualTypeToConvert = type.GetCompatibleGenericBaseType(_knownSymbols.ICollectionOfTType)) != null)
                 {
                     collectionType = CollectionType.ICollectionOfT;

src/libraries/System.Text.Json/gen/Model/CollectionType.cs

@@ -30,6 +30,10 @@ public enum CollectionType
         Queue,
         ImmutableEnumerable,
         MemoryOfT,
-        ReadOnlyMemoryOfT
+        ReadOnlyMemoryOfT,
+        // Only modern .NET (> 5.0) supports IReadOnlySet<T>.
+#if NET
+        IReadOnlySetOfT
+#endif
     }
 }

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

@@ -1344,6 +1344,12 @@ public static partial class JsonMetadataServices
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<TCollection> CreateImmutableEnumerableInfo<TCollection, TElement>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<TCollection> collectionInfo, System.Func<System.Collections.Generic.IEnumerable<TElement>, TCollection> createRangeFunc) where TCollection : System.Collections.Generic.IEnumerable<TElement> { throw null; }
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<TCollection> CreateIReadOnlyDictionaryInfo<TCollection, TKey, TValue>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<TCollection> collectionInfo) where TCollection : System.Collections.Generic.IReadOnlyDictionary<TKey, TValue> where TKey : notnull { throw null; }
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<TCollection> CreateISetInfo<TCollection, TElement>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<TCollection> collectionInfo) where TCollection : System.Collections.Generic.ISet<TElement> { throw null; }
+
+        // Only modern .NET (> 5.0) supports IReadOnlySet<T>.
+#if NET
+        public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<TCollection> CreateIReadOnlySetInfo<TCollection, TElement>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<TCollection> collectionInfo) where TCollection : System.Collections.Generic.IReadOnlySet<TElement> { throw null; }
+#endif
+
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<TCollection> CreateListInfo<TCollection, TElement>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<TCollection> collectionInfo) where TCollection : System.Collections.Generic.List<TElement> { throw null; }
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<System.Memory<TElement>> CreateMemoryInfo<TElement>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonCollectionInfoValues<System.Memory<TElement>> collectionInfo) { throw null; }
         public static System.Text.Json.Serialization.Metadata.JsonTypeInfo<T> CreateObjectInfo<T>(System.Text.Json.JsonSerializerOptions options, System.Text.Json.Serialization.Metadata.JsonObjectInfoValues<T> objectInfo) where T : notnull { throw null; }

src/libraries/System.Text.Json/src/System.Text.Json.csproj

@@ -351,6 +351,10 @@ The System.Text.Json library is built-in as part of the shared framework in .NET
     <Compile Include="$(CoreLibSharedDir)System\Marvin.cs" Link="Common\System\Marvin.cs" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp' and $([MSBuild]::VersionGreaterThanOrEquals('$(TargetFrameworkVersion)', '5.0'))">
+    <Compile Include="System\Text\Json\Serialization\Converters\Collection\IReadOnlySetOfTConverter.cs" />  
+  </ItemGroup>
+
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
     <Compile Include="$(CoreLibSharedDir)System\Collections\Generic\ReferenceEqualityComparer.cs" />
     <Compile Include="$(CoreLibSharedDir)System\Runtime\CompilerServices\IsExternalInit.cs" />

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IEnumerableConverterFactory.cs

@@ -108,6 +108,15 @@ public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializer
                 converterType = typeof(ISetOfTConverter<,>);
                 elementType = actualTypeToConvert.GetGenericArguments()[0];
             }
+            // Only modern .NET (> 5.0) supports IReadOnlySet<T>.
+#if NET
+            // IReadOnlySet<>
+            else if ((actualTypeToConvert = typeToConvert.GetCompatibleGenericInterface(typeof(IReadOnlySet<>))) != null)
+            {
+                converterType = typeof(IReadOnlySetOfTConverter<,>);
+                elementType = actualTypeToConvert.GetGenericArguments()[0];
+            }
+#endif
             // ICollection<>
             else if ((actualTypeToConvert = typeToConvert.GetCompatibleGenericInterface(typeof(ICollection<>))) != null)
             {

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IReadOnlySetOfTConverter.cs

@@ -0,0 +1,47 @@
+// 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.Diagnostics;
+using System.Text.Json.Serialization.Metadata;
+
+namespace System.Text.Json.Serialization.Converters
+{
+    internal sealed class IReadOnlySetOfTConverter<TCollection, TElement>
+        : IEnumerableDefaultConverter<TCollection, TElement>
+        where TCollection : IReadOnlySet<TElement>
+    {
+        private readonly bool _isDeserializable = typeof(TCollection).IsAssignableFrom(typeof(HashSet<TElement>));
+
+        protected override void Add(in TElement value, ref ReadStack state)
+        {
+            // Directly convert to HashSet<TElement> since IReadOnlySet<T> does not have an Add method.
+            HashSet<TElement> collection = (HashSet<TElement>)state.Current.ReturnValue!;
+            collection.Add(value);
+            if (IsValueType)
+            {
+                state.Current.ReturnValue = collection;
+            }
+        }
+
+        protected override void CreateCollection(ref Utf8JsonReader reader, scoped ref ReadStack state, JsonSerializerOptions options)
+        {
+            if (!_isDeserializable)
+            {
+                ThrowHelper.ThrowNotSupportedException_CannotPopulateCollection(Type, ref reader, ref state);
+            }
+
+            state.Current.ReturnValue = new HashSet<TElement>();
+        }
+
+        internal override void ConfigureJsonTypeInfo(JsonTypeInfo jsonTypeInfo, JsonSerializerOptions options)
+        {
+            // Deserialize as HashSet<TElement> for interface types that support it.
+            if (jsonTypeInfo.CreateObject is null && Type.IsAssignableFrom(typeof(HashSet<TElement>)))
+            {
+                Debug.Assert(Type.IsInterface);
+                jsonTypeInfo.CreateObject = () => new HashSet<TElement>();
+            }
+        }
+    }
+}

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

@@ -43,7 +43,7 @@ internal JsonConverter GetConverterInternal(Type typeToConvert, JsonSerializerOp
                     ThrowHelper.ThrowInvalidOperationException_SerializerConverterFactoryReturnsNull(GetType());
                     break;
                 case JsonConverterFactory:
-                    ThrowHelper.ThrowInvalidOperationException_SerializerConverterFactoryReturnsJsonConverterFactorty(GetType());
+                    ThrowHelper.ThrowInvalidOperationException_SerializerConverterFactoryReturnsJsonConverterFactory(GetType());
                     break;
             }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonMetadataServices.Collections.cs

@@ -211,6 +211,27 @@ public static JsonTypeInfo<TCollection> CreateISetInfo<TCollection, TElement>(
                 collectionInfo,
                 new ISetOfTConverter<TCollection, TElement>());
 
+        // Only modern .NET (> 5.0) supports IReadOnlySet<T>.
+#if NET
+        /// <summary>
+        /// Creates serialization metadata for types assignable to <see cref="IReadOnlySet{T}"/>.
+        /// </summary>
+        /// <typeparam name="TCollection">The generic definition of the type.</typeparam>
+        /// <typeparam name="TElement">The generic definition of the element type.</typeparam>
+        /// <param name="options"></param>
+        /// <param name="collectionInfo">Provides serialization metadata about the collection type.</param>
+        /// <returns>Serialization metadata for the given type.</returns>
+        /// <remarks>This API is for use by the output of the System.Text.Json source generator and should not be called directly.</remarks>
+        public static JsonTypeInfo<TCollection> CreateIReadOnlySetInfo<TCollection, TElement>(
+            JsonSerializerOptions options,
+            JsonCollectionInfoValues<TCollection> collectionInfo)
+            where TCollection : IReadOnlySet<TElement>
+            => CreateCore(
+                options,
+                collectionInfo,
+                new IReadOnlySetOfTConverter<TCollection, TElement>());
+#endif
+
         /// <summary>
         /// Creates serialization metadata for types assignable to <see cref="ICollection{T}"/>.
         /// </summary>

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

@@ -376,7 +376,7 @@ public static void ThrowInvalidOperationException_SerializerConverterFactoryRetu
         }
 
         [DoesNotReturn]
-        public static void ThrowInvalidOperationException_SerializerConverterFactoryReturnsJsonConverterFactorty(Type converterType)
+        public static void ThrowInvalidOperationException_SerializerConverterFactoryReturnsJsonConverterFactory(Type converterType)
         {
             throw new InvalidOperationException(SR.Format(SR.SerializerConverterFactoryReturnsJsonConverterFactory, converterType));
         }

src/libraries/System.Text.Json/tests/Common/CollectionTests/CollectionTests.Generic.Read.cs

@@ -687,6 +687,87 @@ public async Task ReadSimpleISetT()
             Assert.Equal(0, result.Count());
         }
 
+        // Only modern .NET (> 5.0) supports IReadOnlySet<T>.
+#if NET
+        [Fact]
+        public async Task ReadNullableGenericStructIReadOnlySetWithNullJson()
+        {
+            var wrapper = await Serializer.DeserializeWrapper<GenericStructIReadOnlySetWrapper<int>?>("null");
+            Assert.False(wrapper.HasValue);
+        }
+
+        [Fact]
+        public async Task ReadIReadOnlySetTOfHashSetT()
+        {
+            IReadOnlySet<HashSet<int>> result = await Serializer.DeserializeWrapper<IReadOnlySet<HashSet<int>>>(@"[[1,2],[3,4]]");
+
+            if (result.First().Contains(1))
+            {
+                AssertExtensions.Equal(new HashSet<int> { 1, 2 }, result.First());
+                AssertExtensions.Equal(new HashSet<int> { 3, 4 }, result.Last());
+            }
+            else
+            {
+                AssertExtensions.Equal(new HashSet<int> { 3, 4 }, result.First());
+                AssertExtensions.Equal(new HashSet<int> { 1, 2 }, result.Last());
+            }
+        }
+
+        [Fact]
+        public async Task ReadHashSetTOfIReadOnlySetT()
+        {
+            HashSet<IReadOnlySet<int>> result = await Serializer.DeserializeWrapper<HashSet<IReadOnlySet<int>>>(@"[[1,2],[3,4]]");
+
+            if (result.First().Contains(1))
+            {
+                Assert.Equal(new HashSet<int> { 1, 2 }, result.First());
+                Assert.Equal(new HashSet<int> { 3, 4 }, result.Last());
+            }
+            else
+            {
+                Assert.Equal(new HashSet<int> { 3, 4 }, result.First());
+                Assert.Equal(new HashSet<int> { 1, 2 }, result.Last());
+            }
+        }
+
+        [Fact]
+        public async Task ReadIReadOnlySetTOfArray()
+        {
+            IReadOnlySet<int[]> result = await Serializer.DeserializeWrapper<IReadOnlySet<int[]>>(@"[[1,2],[3,4]]");
+
+            if (result.First().Contains(1))
+            {
+                Assert.Equal(new HashSet<int> { 1, 2 }, result.First());
+                Assert.Equal(new HashSet<int> { 3, 4 }, result.Last());
+            }
+            else
+            {
+                Assert.Equal(new HashSet<int> { 3, 4 }, result.First());
+                Assert.Equal(new HashSet<int> { 1, 2 }, result.Last());
+            }
+        }
+
+        [Fact]
+        public async Task ReadArrayOfIReadOnlySetT()
+        {
+            IReadOnlySet<int>[] result = await Serializer.DeserializeWrapper<IReadOnlySet<int>[]>(@"[[1,2],[3,4]]");
+
+            Assert.Equal(new HashSet<int> { 1, 2 }, result.First());
+            Assert.Equal(new HashSet<int> { 3, 4 }, result.Last());
+        }
+
+        [Fact]
+        public async Task ReadSimpleIReadOnlySetT()
+        {
+            IReadOnlySet<int> result = await Serializer.DeserializeWrapper<IReadOnlySet<int>>(@"[1,2]");
+
+            Assert.Equal(new HashSet<int> { 1, 2 }, result);
+
+            result = await Serializer.DeserializeWrapper<IReadOnlySet<int>>(@"[]");
+            Assert.Equal(0, result.Count());
+        }
+#endif
+
         [Fact]
         public async Task StackTOfStackT()
         {
@@ -1136,6 +1217,16 @@ public static IEnumerable<object[]> ReadSimpleTestClass_GenericWrappers_NoAddMet
                     SimpleTestClassWithStringToStringIReadOnlyDictionaryWrapper.s_json,
                     typeof(GenericIReadOnlyDictionaryWrapper<string, string>)
                 };
+
+                // Only modern .NET (> 5.0) supports IReadOnlySet<T>.
+#if NET
+                yield return new object[]
+                {
+                    typeof(SimpleTestClassWithStringIReadOnlySetWrapper),
+                    SimpleTestClassWithStringIReadOnlySetWrapper.s_json,
+                    typeof(WrapperForIReadOnlySetOfT<string>)
+                };
+#endif
             }
         }
 
@@ -1173,6 +1264,12 @@ public async Task Read_HigherOrderCollectionInheritance_Works()
         [InlineData(typeof(GenericIListWrapperInternalConstructor<string>), @"[""1""]")]
         [InlineData(typeof(GenericISetWrapperPrivateConstructor<string>), @"[""1""]")]
         [InlineData(typeof(GenericISetWrapperInternalConstructor<string>), @"[""1""]")]
+
+#if NET
+        [InlineData(typeof(GenericIReadOnlySetWrapperPrivateConstructor<string>), @"[""1""]")]
+        [InlineData(typeof(GenericIReadOnlySetWrapperInternalConstructor<string>), @"[""1""]")]
+#endif
+
         [InlineData(typeof(GenericIDictionaryWrapperPrivateConstructor<string, string>), @"{""Key"":""Value""}")]
         [InlineData(typeof(GenericIDictionaryWrapperInternalConstructor<string, string>), @"{""Key"":""Value""}")]
         [InlineData(typeof(StringToStringIReadOnlyDictionaryWrapperPrivateConstructor), @"{""Key"":""Value""}")]
@@ -1271,6 +1368,12 @@ public static IEnumerable<object[]> CustomInterfaces_Enumerables()
             yield return new object[] { typeof(IDerivedICollectionOfT<string>) };
             yield return new object[] { typeof(IDerivedIList) };
             yield return new object[] { typeof(IDerivedISetOfT<string>) };
+
+            // Only modern .NET (> 5.0) supports IReadOnlySet<T>.
+#if NET
+            yield return new object[] { typeof(IDerivedIReadOnlySetOfT<string>) };
+#endif
+
         }
 
         public static IEnumerable<object[]> CustomInterfaces_Dictionaries()