Allow byref-like closure over byref(-like) locals

[GeeLaw]

An enhancement of #10209 #10210 . This is moved from discussion 10210 reply 2 with the example improved.

Abstract. A closure implemented by a byref-like value type should be able to close over byref(-like) locals. Those locals should be captured by pointer. This is safe as long as the byref-like value is scoped for the receiving method.

Example. Suppose

interface IUnescaping
{
  void Invoke(int[] array);
}

// Note `scoped`, promising nested lifetime.
static void Foo<TUnescaping>(scoped ref TUnescaping action)
  where TUnescaping : IUnescaping, allows ref struct
{
  action.Invoke(new int[1]);
}

and consider the following usage

int i = 0;
ref int r = ref i;
Span<int> s1 = default;
Span<int> s2 = default;
ref Span<int> s = ref s1;

Console.WriteLine("i, {0}; r, {1}; s1, {2}; s2, {3}; s, {4}",
  i,
  Unsafe.AreSame(ref r, ref i) ? "i   " : "a[0]",
  s1.Length == 0 ? "default" : "init   ",
  s2.Length == 0 ? "default" : "init   ",
  Unsafe.AreSame(ref s, ref s1) ? "s1" : "s2"
); // Call this statement "!".

Foo(array =>
{
  ++i;
  r = ref array[0]; // rebind byref local
  s = array;        // assign via ref to byref-like
  s = ref s2;       // rebind byref local to byref-like
});

// Repeat "!".

Foo(array =>
{
  ++i;
  r = ref array[0]; // rebind byref local
  s = array;        // assign via ref to byref-like
  s = ref s1;       // rebind byref local to byref-like
});

// Repeat "!".

The intended output is

i, 0; r, i   ; s1, default; s2, default; s, s1
i, 1; r, a[0]; s1, init   ; s2, default; s, s2
i, 2; r, a[0]; s1, init   ; s2, init   ; s, s1

A correct transformation appears to be

Locals locals;
locals.i = 0;
locals.r = ref Unsafe.AsRef(ref locals.i);
locals.s1 = default;
locals.s2 = default;
locals.s = &locals.s1;

Console.WriteLine("i, {0}; r, {1}; s1, {2}; s2, {3}; s, {4}",
  i,
  Unsafe.AreSame(ref locals.r, ref locals.i) ? "i   " : "a[0]",
  locals.s1.Length == 0 ? "default" : "init   ",
  locals.s2.Length == 0 ? "default" : "init   ",
  Unsafe.AreSame(ref *locals.s, ref locals.s1) ? "s1" : "s2"
);

// Again, we're utilizing the fact of indifference between
// managed and unmanaged pointers to byref-like types.
Locals.Closure1 c1 = new Locals.Closure1(&locals);
Foo(ref c1);

// Similarly for the rest of the code.

// Regardless of the captures, the locals "display
// struct" should always be generated as byref-like.
unsafe ref struct Locals
{
  public int i;
  public ref int r;
  public Span<int> s1;
  public Span<int> s2;
  // There's no semantic difference between
  // managed versus unmanaged pointers to byref-like types,
  // because byref-like values always live on stack and never move.
  // This is a current contract as C# doesn't require `fixed`
  // to take the address of a byref-like local.
  public Span<int>* s;
  // If the scope has captured locals (normal closures/delegates),
  // then the fields will contain DisplayClass instances.

  public readonly ref struct Closure1 : IUnescaping
  {
    private readonly Locals* locals;
    public Closure1(Locals* locals) { this.locals = locals; }
    void IUnescaping.Invoke(int[] array)
    {
      ++locals->i;
      locals->r = ref array[0];
      *locals->s = array;
      locals->s = &locals->s2;
    }
  }
  // Similarly for Closure2.
}

Example 2. Suppose string.Create is implemented using value delegates...

// imaginary in string
public interface IFill<T>
{
  void Invoke(Span<T> span);
}
public static string Create<TFillChars>(int length, scoped ref TFillChars fill)
  where TFillChars : IFill<char>, allows ref struct
{
  string result = FastAllocateString(length);
  fill.Invoke(result);
  return result;
}

// usage
static string Repeat(ReadOnlySpan<char> one, int n)
{
  return string.Create(checked(one.Length * n), span =>
  {
    for (int i = 0; i != n; ++i)
      one.CopyTo(span.Slice(one.Length * n, one.Length));
    // Closes over `one`.
  });
}