[Swift projection tooling] Bridging generic constraints for metadata retrieval

[jkurdek]

Issue Summary

In the current implementation, we need to dynamically execute specific behaviors in generic contexts based on the type being processed. These behaviors include operations such as loading metadata or creating an instance of a C# object from a Swift handle.

The complexity arises because the types can either:

1. Originate from Swift (e.g., types conforming to ISwiftObject).
2. Be non-Swift types, such as primitive types or C#-specific types that conform to protocols.

Since these cases do not share a common interface or base class, we cannot enforce a shared abstraction to generalize behavior.

Current Approach

The current implementation uses helper classes/methods and leverages MakeGenericType (compatible with NativeAOT) to dynamically dispatch type-specific behavior. The implementation looks like this:

void DoSomething<T>()
{
    var type = typeof(T);

    if (typeof(ISwiftObject).IsAssignableFrom(type))
    {
        var helperType = typeof(DoSomethingHelper<>).MakeGenericType(type);
        helperType.GetMethod("DoForSwiftObject")!.Invoke(null, null);
    }
    else
    {
        // Handle other cases...
    }
}

This approach ensures compatibility with NativeAOT while working around the limitations of C#, which does not support constructs like:

void DoSomething<T>()
{
    if (T is ISwiftObject)
        T.DoSomething();
    else
        // Handle other cases...
}

However, this pattern introduces significant performance overhead due to:

• The use of reflection (MakeGenericType, GetMethod, and Invoke).
• The lack of caching, which leads to repeated and unnecessary reflection-based operations.

Problem Statement

The current pattern is slow and poses a significant performance bottleneck. Since the majority of calls into Swift involve this pattern, it impacts the overall efficiency of the system. We need to investigate alternatives or optimizations to reduce the performance overhead.

---

We already have a cache for this pattern when it comes to TypeMetadata

• related issue: [Swift runtime features] Validate metadata pointers before saving them into cache #2966

[jkurdek]

Yep, this is fine and it's contractual. We document it here: https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/intrinsic-requiresdynamiccode-apis#typemakegenerictypetype-method-net-9

This was added because it's the only way to bridge constraints currently and people use these patterns to solve the same problems that this is solving.

It's not possible to express this in IL right now either (the runtime validates the constraints meet in the uninstantiated forms - if they happen to be met for a particular substitution, it's not enough). There's a proposal of an IL extension that would allow this at dotnet/runtime#97084 but without a commitment from C# team to use this, it's not moving forward.

If perf is of concern, consider e.g. caching a delegate (use MethodInfo.CreateDelegate to get a delegate and cache it using the generic parameters as a key). Of course then one needs to think about unloadability, etc.

Originally posted by @MichalStrehovsky in #2958 (comment)

[jkurdek]

I don't understand how the compiler knows - the callsite to MakreGenericType here can guarnatee that the second type parameter is a ref type, but the first type is unconstrained. It's possible that all current uses are ref types, but I don't think we can guarantee that constrain.

Let's also think about how to solve this some other way avoiding static virtual methods.

Originally posted by @vitek-karas in #2958 (comment)

[jkurdek]

Even though this works and is effectively supported as the official solution - for our use case this is going to be a perf problem. I'm thinking about cases like calling a swift method which takes a protocol parameter. We will run through this for every call to marshal the parameter. That feels rather expensive.

For the instance based cases we can do way better by simply having an instance method on ISwiftObject. I'll have to think about the cases where it's not instance based...

Originally posted by @vitek-karas in #2958 (comment)

[jkurdek]

I don't understand how the compiler knows - the callsite to MakreGenericType here can guarnatee that the second type parameter is a ref type, but the first type is unconstrained.

The first one is constrained to be typeof(T), the second is typeof(U). We just model it as if there was a call from the generic method to the method on the instantiated generic type. (The PR that added this was dotnet/runtime#99037 if you're interested.)

Even though this works and is effectively supported as the official solution - for our use case this is going to be a perf problem.

You could add a hashtable in front of it. This should have performance characteristics close to doing a generic virtual method call (that one is also a hashtable lookup). Maybe a bit slower but not by much. People call generic virtual methods in perf critical code all the time (often because they're unaware GVMs are the slowest form of calls in .NET, much much slower than delegates, but I digress).

if (!s_dict.TryGetValue((typeof(T), typeof(U)), out var del))
{
    if (typeof(ISwiftObject).IsAssignableFrom(typeof(T)))
    {
        var helperType = typeof(ProtocolConformanceDescriptorHelper<,>).MakeGenericType(typeof(T), typeof(U));
        del = helperType.GetMethod("GetProtocolConformanceDescriptor")!.CreateDelegate<Func<ProtocolConformanceDescriptor>>();
    }
    else
    {
        del = null;
    }
    s_dict.Add((typeof(T), typeof(U)), del);
}

if (del != null)
{
    result = del();
    return true;
}

result = null;
return false;

Originally posted by @MichalStrehovsky in #2958 (comment)

[jkurdek]

Actually, this can be optimized into a delegate invocation. If something like dotnet/runtime#109679 ever lands in the JIT/VM, even the delegate invocation would go away and this would be a zero-cost abstraction. We could make this into a zero cost abstraction on the native AOT side too if necessary, but even as-is, it's just a static constructor check followed by delegate invocation.

class DelegateCache<T, U>
{
    public static Func<ProtocolConformanceDescriptor> Func { get; } =
        typeof(ISwiftObject).IsAssignableFrom(typeof(T))
        ? typeof(ProtocolConformanceDescriptorHelper<,>).MakeGenericType(typeof(T), typeof(U)).GetMethod("GetProtocolConformanceDescriptor")!.CreateDelegate<Func<ProtocolConformanceDescriptor>>()
        : null;
}

static bool TryGetProtocolConformanceDescriptor<T, U>(out ProtocolConformanceDescriptor result)
{
    var d = DelegateCache<T, U>.Func;
    if (d == null)
    {
        result = null;
        return false;
    }

    result = d();
    return true;
}

Originally posted by @MichalStrehovsky in #2958 (comment)