Return by ref of captured local

[bernd5]

The reference implementation roslyn currently rejects the following code with the error message:

error CS8168: Cannot return local 'x' by reference because it is not a ref local

Code:

using System;

class X
{
    public static void Main(string?[]? args)
    {
        int x = 1;
        var lambda = ref int () =>
        {
            return ref x;
        };

        ref int r = ref lambda();
        r++;
        r++;
        Console.WriteLine(x);
    }
}

If I write the lambda "manually" I get something like:

using System;
class Capture
{
    public int x;

    public ref int Invoke()
    {
        return ref x;
    }
}

public delegate ref T RefDelegate<T>();

class X
{
    public static void Main()
    {
        var c = new Capture();
		
        c.x = 1;

	RefDelegate<int> lambda = c.Invoke;
        ref int r = ref lambda();
        r++;
        r++;
        Console.WriteLine(c.x);
	Console.WriteLine(r);
    }
}

which compiles and runs perfectly fine.

Is there any reason why the code is rejected? Is this specified in the spec or a compiler limitation?
Refences to class fields should be fine...

[bernd5]

If I write the lambda like:

  var lambda = ref int () =>
  {
      ref int scopedXref =ref System.Runtime.CompilerServices.Unsafe.AsRef(x);
      return ref scopedXref;
  };

I can make the captured local scoped. But because it is actually a field which lives on the heap, shouldn't it be implicitly scoped?

[333fred]

But because it is actually a field which lives on the heap

This is an implementation detail. You cannot depend on it.

[bernd5]

This is true, but even if it would live on the stack (e.g. capture storage is implemented as sturct) the captured values must live at least as long as the lambda itself.

Sample:

using System;
struct Capture
{
    public int x;

    public Capture(int x)
    {
        this.x = x;
    }

    public ref int Invoke()
    {
        return ref System.Runtime.CompilerServices.Unsafe.AsRef(in x);
    }
}

class X
{
    public static void Main(string?[]? args)
    {
        Capture capture = new(1);

        //we can't create a "real" delegate because the struct would be boxed...
        ref int r = ref capture.Invoke();
        r++;
        r++;
        Console.WriteLine(capture.x);
    }
}

[bernd5]

Ah, then the lifetime of the lambda must be extended to the lifetime of the returned captured reference.
This is the point, right?

[333fred]

This is the point, right?

That's correct.