System.Text.Json source generator and immutable/custom types

[ithline]

Hello .Net team,
I've been trying out the new System.Text.Json source generator with the recently released net6.0-preview.7 and I have encountered few issues that I'm unable to solve.

1. Are init-only properties supported for deserialization using the new JsonTypeInfo API? My use case is strongly typed configuration objects that are read from and written to a file. To reduce the overhead of reading values, I store the last instance in "cache". So to avoid mutating the current state, all properties are defined as { get; init; }.
2. How can I support custom (immutable) collections? When annotating JsonSerializerContext with JsonSerializableAttribute, a property for the collection type is created, but fails at runtime, because it cannot be constructed. I've tried to manually add JsonTypeInfo<MyImmutableList> to the serializer context, but then there is not way to add it to the JsonTypeInfo GetTypeInfo(Type type) method, therefore the serializer cannot find my custom value.
3. I tried to write custom converter for MyImmutableList and annotate the type, but then I stumbled upon problem with serialization/deserialization of element types. In the Read/Write methods of JsonConverter<T> I cannot find a way to resolve JsonTypeInfo and resolving a converter by calling options.GetConverter(typeof(MyElement)) puts me back into square one with RequiresUnreferencedCode warnings. I also cannot instantiate a new instance of MyJsonContext with the options passed into the JsonConverter<T>.Read/Write methods, because each options instance can be associated only with one context.

Minimal repro of my use case.

internal sealed class MyImmutableList : IEnumerable<MyElement>
{
    private readonly ImmutableList<MyElement> _inner;
    private MyImmutableList(ImmutableList<MyElement> inner)
    {
        _inner = inner;
    }

    public static MyImmutableList CreateRange(params MyElement[] items)
    {
        return new MyImmutableList(items.ToImmutableList());
    }
    public IEnumerator<MyElement> GetEnumerator() => _inner.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}
internal sealed class MyElement
{
    public string? Name { get; set; }
}
internal sealed class MyRootObject
{
    public string? Id { get; set; }
    public MyImmutableList? Items { get; set; }
}
[JsonSerializable(typeof(MyRootObject), GenerationMode = JsonSourceGenerationMode.Metadata)]
[JsonSerializable(typeof(MyElement), GenerationMode = JsonSourceGenerationMode.Metadata)]
[JsonSerializable(typeof(MyImmutableList), GenerationMode = JsonSourceGenerationMode.Metadata)]
internal sealed partial class MyJsonContext : JsonSerializerContext
{
}

var json = @"{ ""Id"": ""abc"",	""Items"": [ { ""Name"": ""a"" } ] }";

// all properties are null when using init;
// otherwise deserialization fails on Items property
var deserialized = JsonSerializer.Deserialize(json, MyJsonContext.Default.MyRootObject);

[huoyaoyuan]

Can the code work with old reflection approach, instead of source generator?
Custom collection may require custom converter.

[ithline]

init properties don't work at all using the source generator, but work without problems using the reflection based serializer.

I have custom converter that basically deserializes array of inner elements and then it constructs the collection, but it can be used only with the reflection based deserialization as there is no way inside the custom JsonConverter<T> to resolve JsonTypeInfo and resolving converter from the options instance throws warnings about unreferenced code.

internal class MyImmutableListConverter : JsonConverter<MyImmutableList>
{
    public override MyImmutableList? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        // warns about unreferenced code
        var array = JsonSerializer.Deserialize<MyElement[]>(ref reader, options);
        return MyImmutableList.CreateRange(array);

        // warns about unreferenced code and i'm not sure about the cast
        var elementConverter = (JsonConverter<MyElement>)options.GetConverter(typeof(MyElement));
        var list = new List<MyElement>();
        while (reader.Read())
        {
            if (reader.TokenType == JsonTokenType.EndArray)
            {
	            return MyImmutableList.CreateRange(list.ToArray());
            }
            list.Add(elementConverter.Read(ref reader, typeof(MyElement), options));
        }
        throw new JsonException();
    }
    public override void Write(Utf8JsonWriter writer, MyImmutableList value, JsonSerializerOptions options)
    {
        throw new NotImplementedException();
    }
}

I don't mind having to adding manually JsonTypeInfo to the serializer context, except there is no way to add this to the generated JsonTypeInfo GetTypeInfo(Type type) method.

[JsonSerializable(typeof(MyElement), TypeInfoPropertyName = "MyElementInfo")]
internal partial class MyJsonContext : JsonSerializerContext
{
    public JsonTypeInfo<MyImmutableList> MyImmutableListInfo => JsonMetadataServices.CreateImmutableEnumerableInfo<MyImmutableList, MyElement>(
        Options,
        () => MyImmutableList.CreateRange(),
	MyElementInfo,
        default,
        null,
        (items) => MyImmutableList.CreateRange(items.ToArray()));
}