Allowing ref types as type arguments for type parameters accept ref struct types

[hez2010]

With the support for ref struct for interfaces and type arguments, we are now able to emulate ref in type argument via creating our own ref struct with a ref field.

using System;

var x = 1;
var box = new Ref<int>(ref x);
Bar(box);
Foo(box, 42);
Console.WriteLine(x);

void Bar<T>(T x) where T : allows ref struct { }

void Foo<TBox, TValue>(TBox box, TValue value) where TBox : IRef<TValue>, allows ref struct
{
    box.Target = value;
}

ref struct Ref<T>(ref T target) : IRef<T>
{
    private readonly ref T _target = ref target;
    public ref T Target => ref _target;
}

interface IRef<T>
{
    ref T Target { get; }
}

The above code will be able to compile and work fine.

I suggest allowing passing ref T to a type parameter which allows ref struct as its type argument as well, so that the above code can be:

using System;

var x = 1;
Bar(ref x); // `T` is `ref int`
Foo(ref x, 42); // `TBox` is `ref int`, `TValue` is `int`
Console.WriteLine(x);

void Bar<T>(T x) where T : allows ref struct { }

void Foo<TBox, TValue>(TBox target, TValue value) where TBox : ref TValue // `where TBox : ref TValue` indicates `TBox` is `ref TValue`, and implies `TBox : allows ref struct`
{
    target = value;
}

A typical use case of this is that we can now pass ref T as the type argument of Action<T> and Func<T> without need of lowering to an unspeaking delegate type:

Func<ref int, int> f = Foo1;
Action<ref int> f = Foo2;
int Foo1(ref int x) { ... }
void Foo2(ref int x) { ... }

Prototype of runtime support for this: dotnet/runtime@main...hez2010:byref_generics

[tfenise]

Consider

void Foo<T>(ref T arg) where T : allows ref struct { }

What is the signature of Foo<ref int>? void (ref ref int)? What even is ref ref int?

[HaloFour]

Presumably enabling Foo<ref int> would have to come with another anti-constraint which would force the method to only do things with T that would be safe if T is a ref type, which would probably preclude allowing the method to take a ref T, or pass one as an argument.

[siegfriedpammer]

Isn't that covered by #5321?

[BreyerW]

Your link is for delegates only while this prototype allows for more general use of ref everywhere eg in static/instance methods or on class/struct that have generics and its methods/properties use those generics (but not fields)

Like this

class Example<T>  where T: ref T
{
    public void Test(T refAllowed){

    }
}