Support "generic" (dotnet runtime types only) AOT

[rmannibucau]

Is your feature request related to a problem? Please describe.
I'm targetting AOT compilation and using YamlDotNet.
The restriction to use only dotnet runtime types is fine in this particular context and since the (de)serialized structure(s) is not known upfront, using only List, Dictionary<object,object> and primitives+string is ok.

Main issue is that out of the box the yamlcontext generators don't work for this use case and there is no default implementation.

Describe the solution you'd like
Ideally it should work by building a default (De)Serializer - instead of testing Dictionary<,> it can test with object too (same for lists) and it should be close to work.

Describe alternatives you've considered
Implement a custom static context (mainly a draft since it doesn't cover all cases):

using YamlDotNet.Serialization;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.TypeInspectors;

namespace Workaround.YamlDotNet;

// note: aot generator doesn't work with generic containers so let's do it outselves
// StaticDeserializerBuilder has fallbacks (Dictionary<object, object>) and List<object>)
// in its constructor so let's just use them and only support that
public class YamlContext : StaticContext
{
    public static readonly YamlContext Instance = new();

    public override bool IsKnownType(Type type)
    {
        return false;
    }

    public override ITypeResolver GetTypeResolver() => SimpleTypeResolver.Instance;

    public override StaticObjectFactory GetFactory() => SimpleStaticObjectFactory.Instance;

    public override ITypeInspector GetTypeInspector() => SimpleTypeInspector.Instance;
}

internal class SimpleTypeInspector : TypeInspectorSkeleton
{
    internal static readonly SimpleTypeInspector Instance = new();

    public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container) =>
        [];

    public override string GetEnumName(Type enumType, string name) => name;

    public override string GetEnumValue(object enumValue) => enumValue.ToString()!;
}

internal class SimpleStaticObjectFactory : StaticObjectFactory
{
    internal static readonly SimpleStaticObjectFactory Instance = new();

    public override object Create(Type type)
    {
        if (
            typeof(Dictionary<object, object>) == type
            || typeof(IDictionary<object, object>) == type
        )
        {
            return new OrderedDictionary<object, object>();
        }

        if (
            typeof(Dictionary<string, object>) == type
            || typeof(IDictionary<string, object>) == type
        )
        {
            return new OrderedDictionary<string, object>();
        }

        if (typeof(List<object>) == type || typeof(IList<object>) == type)
        {
            return new List<object>();
        }

        if (typeof(IList<IDictionary<string, object>>) == type)
        {
            return new List<IDictionary<string, object>>();
        }

        throw new InvalidOperationException($"Unknown type: '{type.FullName}'");
    }

    public override Array CreateArray(Type type, int count)
    {
        throw new NotImplementedException("shoudn't be called");
    }

    public override bool IsDictionary(Type type)
    {
        return type == typeof(Dictionary<object, object>)
            || type == typeof(IDictionary<object, object>)
            || type == typeof(IDictionary<string, object>)
            || type == typeof(IDictionary<string, string>)
            || type == typeof(Dictionary<string, string>)
            || type == typeof(IDictionary<string, int>)
            || type == typeof(Dictionary<string, int>)
            || type == typeof(IDictionary<string, bool>)
            || type == typeof(Dictionary<string, bool>)
            || type == typeof(IDictionary<string, double>)
            || type == typeof(Dictionary<string, double>)
            || type == typeof(IDictionary<object, string>)
            || type == typeof(Dictionary<object, string>)
            || type == typeof(IDictionary<object, int>)
            || type == typeof(Dictionary<object, int>)
            || type == typeof(IDictionary<object, bool>)
            || type == typeof(Dictionary<object, bool>)
            || type == typeof(IDictionary<object, double>)
            || type == typeof(Dictionary<object, double>);
    }

    public override bool IsArray(Type type)
    {
        return false;
    }

    public override bool IsList(Type type)
    {
        return type == typeof(List<object>)
            || type == typeof(IList<object>)
            || type == typeof(List<string>)
            || type == typeof(IList<string>)
            || type == typeof(List<bool>)
            || type == typeof(IList<bool>)
            || type == typeof(List<int>)
            || type == typeof(IList<int>);
    }

    public override Type GetKeyType(Type type)
    {
        if (
            type == typeof(IDictionary<object, object>)
            || type == typeof(IDictionary<object, int>)
            || type == typeof(IDictionary<object, double>)
            || type == typeof(IDictionary<object, bool>)
            || type == typeof(Dictionary<object, object>)
            || type == typeof(Dictionary<object, int>)
            || type == typeof(Dictionary<object, double>)
            || type == typeof(Dictionary<object, bool>)
        )
        {
            return typeof(object);
        }

        if (
            type == typeof(IDictionary<string, object>)
            || type == typeof(IDictionary<string, int>)
            || type == typeof(IDictionary<string, double>)
            || type == typeof(IDictionary<string, bool>)
            || type == typeof(Dictionary<string, object>)
            || type == typeof(Dictionary<string, int>)
            || type == typeof(Dictionary<string, double>)
            || type == typeof(Dictionary<string, bool>)
        )
        {
            return typeof(string);
        }

        return typeof(string); // normally it is always that so it is a safe default for us
    }

    public override Type GetValueType(Type type)
    {
        if (
            type == typeof(Dictionary<object, object>)
            || type == typeof(List<object>)
            || type == typeof(IDictionary<object, object>)
            || type == typeof(IList<object>)
        )
        {
            return typeof(object);
        }

        if (
            type == typeof(List<IDictionary<string, object>>)
            || type == typeof(IList<IDictionary<string, object>>)
        )
        {
            return typeof(IDictionary<string, object>);
        }

        if (
            type == typeof(IDictionary<string, string>)
            || type == typeof(IDictionary<string, string>)
            || type == typeof(List<string>)
            || type == typeof(IList<string>)
        )
        {
            return typeof(string);
        }

        if (
            type == typeof(IDictionary<string, int>)
            || type == typeof(IDictionary<string, int>)
            || type == typeof(List<int>)
            || type == typeof(IList<int>)
        )
        {
            return typeof(int);
        }

        if (
            type == typeof(IDictionary<string, double>)
            || type == typeof(IDictionary<string, double>)
            || type == typeof(List<double>)
            || type == typeof(IList<double>)
        )
        {
            return typeof(double);
        }

        if (
            type == typeof(IDictionary<string, bool>)
            || type == typeof(IDictionary<string, bool>)
            || type == typeof(List<bool>)
            || type == typeof(IList<bool>)
        )
        {
            return typeof(bool);
        }

        throw new InvalidOperationException($"Unknown type: '{type.FullName}'");
    }

    public override void ExecuteOnDeserializing(object value) { }

    public override void ExecuteOnDeserialized(object value) { }

    public override void ExecuteOnSerializing(object value) { }

    public override void ExecuteOnSerialized(object value) { }
}

internal class SimpleTypeResolver : ITypeResolver
{
    public static readonly SimpleTypeResolver Instance = new();

    public Type Resolve(Type staticType, object? value)
    {
        return staticType;
    }
}

[EdwardCooke]

For the object data type, I’m going off of 2 maybe 3 year old memory, aot throws warnings when doing list and dictionary’s using the object type due to not being able to trim them down. That may not be the case anymore. We can for sure add defaults like you propose, I wonder how that would actually work in the end though. AoT really likes to know the type and what is used on that type to do any trimming, otherwise you’ll end up with wildly interests in your published binary. It’ll be a bit before I can revisit the static analyzer but I am willing to see what can be done. I’ve also thought about creating a composite static context that can reference multiple static contexts so things like this would be easier.

[rmannibucau]

My understanding would be to do like json does, ie you register converters for types (list, string, ..., with generics) and when hit object you try to find the closest registered type or you go with YamlValue models but both options solve the issue to load in mem in aot mode an unknown structure.

So it is not about handling object itself but using missing object type as a kind of flag IMHO.