Proposal: open generic type support for generic attributes

[hez2010]

Open generic type in generic attributes

• Proposed
• Prototype: Done
• Implementation: Not Started
• Specification: Not Started

Summary

Enable open generic types as type arguments in generic attributes.

Motivation

Allowing open generic types in generic attributes can enable many scenarios which are not possible or hard to do today.

One of those scenarios is extension type erasure codegen as proposed in #8194, with open generic types, extension types can be lowered to a generic attribute with its underlying type to allow consuming:

// with extension E<T> for T:
void Foo<T>([Extension<E<T>>] T underlying); //  System.Extension`1 (new)

Proposal

Allowing to use type parameter of a type or method in generic attributes:

[Attr<T>]
class Foo<[Attr<T>] T>
{
    [Attr<T>] void Method([Attr<T>] int p);

    [Attr<T, U>] void GenericMethod<[Attr<T, U>] U>([Attr<T, U>] int p);

    [Attr<T>]
    int Property
    {
        [Attr<T>] get;
        [Attr<T>] set;
    }

    [Attr<T>] int field;

    [Attr<T>]
    event Action<int> e
    {
        [Attr<T>] add;
        [Attr<T>] remove;
    }
}

class AttrAttribute<T> : Attribute { }
class AttrAttribute<T, U> : Attribute { }

The codegen strategy is straightforward: emit !T and !!U for the corresponding generic arguments.

Considerations

Compatibility

It's completely expressible with today's metadata, and already supported by coreclr.

Runtime changes

This doesn't require a runtime change in the native side. We only need to alter System.Private.CoreLib to make it pass the generic context while getting attributes.

The runtime needs to skip instantiating a generic attribute if generic context is not provided, that is, typeof(Foo<>).GetCustomAttributes() will return an empty array, while typeof(Foo<int>).GetCustomAttributes() will return an array containing AttrAttribute<int>. This doesn't affact GetCustomAttributesData as GetCustomAttributeData is not trying to instantiating an attribute, instead it load data from the metadata directly, so typeof(Foo<>).GetCustomAttributesData() will return an array containing the attribute data of AttrAttribute<T>.

Such changes have been implemented in dotnet/runtime#103213, which is a trivial change for the runtime.

Concern

Unfortunately, we cannot get an attribute instance with open generic types from a generic parameter:

class Foo<[Attr<T>] T>
{
    void GenericMethod<[Attr<T, U>] U>(int p);
}

Today we can only get an attribute instance from a generic parameter directly, which means we need to call GetCustomAttributes() on a generic argument of a generic type definition or a generic method definition. In this case the generic context is stripped so that we cannot instantiate the attribute with open generics here (because we don't have the generic instantiation).

While this doesn't affect GetCustomAttributesData() as it doesn't instantiate the attribute instance.

If this is not acceptable, we may need to introduce some new overloads for GetCustomAttributes to allow passing the generic instantiations manually.