Anonymous-Params-delegate is generated incorrectly with AllowRefStructFlag

[bernd5]

Version Used:

Steps to Reproduce:

Compile the following code:

var counter = Counter;
counter.Invoke();

void Counter(params int[] arr)
{
}

Expected Behavior:
The compiler should generate an unspeakable delegate type like:

[CompilerGenerated]
internal delegate void <>f__AnonymousDelegate0<T1>(params T1[] arg);

Actual Behavior:

It generates code like:

[CompilerGenerated]
internal delegate void <>f__AnonymousDelegate0<T1>(params T1[] arg) where T1: allows ref struct;

If you look in dotPeek for example and have a look at the TypeParameter flags you can see 0x0020 is set.

The value is defined here: it means allows ref struct

[jjonescz]

Why would that be incorrect? Is anything broken by the compiler generating the delegate with allows ref struct?

Btw, the behavior follows the feature proposal:

If target runtime supports allows ref struct constraints, generic anonymous delegate types will include allows ref struct constraint for their type parameters. This will enable substitution of those type parameters with ref struct types and other type parameters with allows ref struct constraint.

[bernd5]

It is correct without usage as array element type.

E.g.:

internal delegate void <>f__AnonymousDelegate0<T1>(T1 arg) where T1: allows ref struct;

would be very well.

But

internal delegate void <>f__AnonymousDelegate0<T1>(params T1[] arg) where T1 : allows ref struct;

violates the following part of the proposal:

A type parameter bound by allows ref struct has all of the behaviors of a ref struct type:

Instances of it cannot be boxed
Instances participate in lifetime rules like a normal ref struct
The type parameter cannot be used in static fields, elements of an array, etc ...
Instances can be marked with scoped

Any usage of the delegate with an ref-like type as typeargument would be invalid. Currently the runtime simply does not care (and roslyn enforces that such delegate types can't be declared by a user).

E.g.

internal delegate void SomeDelegate0<T1>(params T1[] arg) where T1 : allows ref struct;

emits the following diagnostic: CS0611: Array elements cannot be of type T1

[jaredpar]

Think that part of the spec needs to be limited to using allows ref struct where it would be legal.