"Only called" delegate parameters

[TahirAhmadov]

Currently, some methods which accept a delegate parameter, have an overload for passing an argument to said delegate, in order to avoid creating a closure context, like Dictionary.GetOrAdd, etc.
I came up with an idea of how to accomplish the goal - allow closures without allocations - in a way which is universal. For methods which are known to call the delegate only and do not store it anywhere, we introduce a new keyword - onlycalled:

TValue GetOrAdd(TKey key, onlycalled Func<TKey, TValue> valueFactory)
{
  if(!this.TryGetValue(key, out var res))
    this[key] = res = valueFactory(key);
  this._valueFactory = valueFactory; // error: valueFactory cannot be stored
  return res;
}

void Foo(string prefix)
{
  string suffix = "def";
  var x = dict.GetOrAdd("abc", key => prefix + key + suffix);
}

What happens in the above case is that GetOrAdd signature guarantees that valueFactory is called only during execution of GetOrAdd, and suffix can therefore be accessed directly from the stack frame of Foo.

The next question became, how to implement this, and here I'm not 100% if it's feasible or how expensive it is.

[HaloFour]

I think this is relevant: #1060

I think trying to make this work with normal delegate types would require Object Stack Allocation.

[TahirAhmadov]

My idea was, the stackframe of Foo is known to the compiler; it generates a special un-speakable struct type, which matches the layout of the parameters/locals of Foo:

struct <MANGLED>Closure
{
  string prefix; // the parameters come first
  string suffix; // the locals come next
}

The GetOrAdd actually gets a signature like this:

struct OnlyCalledDelegate<T> // this is added to the BCL
{
  IntPtr ClosureStructRef;
  T Delegate;
}
TValue GetOrAdd(TKey key, OnlyCalledDelegate<Func<TKey, TValue>> valueFactory) { ... }

And when invoking GetOrAdd:

var x = dict.GetOrAdd(..., OnlyCalledDelegate.Create(key=> { ... }));

OnlyCalledDelegate.Create is a special helper method which stores Foo stackframe as IntPtr for later access. The delegate receives this parameter of type ref <MANGLED>Closure, and compiler changes accessing a closure variable like suffix to essentially this.suffix, similarly to calling a struct method. The aforementioned ClosureStructRef is un-safe converted to ref <MANGLED>Closure.

I hope what I wrote above isn't too crazy :)

[TahirAhmadov]

Actually, why not just add the delegate method as a member of the <MANGLED>Closure, and create a delegate whose Target is set to ref <MANGLED>Closure, but is actually the same value as the stackframe of Foo? Then we don't need OnlyCalledDelegate<T> at all, and the parameter is just decorated with a hidden attribute when onlycalled is used.

[svick]

why not [...] create a delegate whose Target is set to ref <MANGLED>Closure

I don't see how that would work. Target is an object and you can't store a ref in that.

[TahirAhmadov]

Duh, you're right, of course. Back to the OnlyCalledDelegate<T> struct idea.

[Xyncgas]

What if the function is inside a ref struct so it cant be stored and you can hide the Func<E,T> by making it private and call it some other way