LDM Notes for April 22nd, 2026

[333fred]

https://github.com/dotnet/csharplang/blob/main/meetings/2026/LDM-2026-04-22.md

Agenda

• Unsafe evolution, continued
  • Signature unsafe and unsafe contexts
  • Transitional diagnostics for pointer-signature calls

[TahirAhmadov]

Just to make sure I understand, under new rules, Unsafe.As etc will become caller unsafe, right? And then in my code I can put the invocation inside an unsafe block, and my method will be "caller safe", provided I make sure that Unsafe call is properly tested etc.?

Also, given that pointer types themselves are no longer unsafe, does that mean method pointers don't require the method to be declared as caller unsafe, and #7785 becomes much easier to use in the real world with function pointers? PS. Meaning, just the method pointer invocation can be wrapped in an unsafe block and the rest of the API surface area stays "caller safe"

[TahirAhmadov]

I'm not sure I follow, I would need to see a more concrete example.

Please see this comment.

internal readonly IntPtr mPtr;

// current rules:
public unsafe static ValueAction Create<TState>(TState state, delegate*<TState, void> mPtr) where TState : class
        => new(state, (IntPtr) mPtr);
public unsafe void Invoke()
        => ((delegate*<object, void>) mPtr)(state);

// future rules:
public static ValueAction Create<TState>(TState state, delegate*<TState, void> mPtr) where TState : class
        => new(state, (IntPtr) mPtr);
public void Invoke()
{
  unsafe
  {
    ((delegate*<object, void>) mPtr)(state);
  }
}

[jjonescz]

I see. Yes, that should compile under the new rules.

[333fred]

To be clear; yes, it will compile. However, the new unsafe rules don't mean you are free to go hog-wild, it means you are better able to express how your domain encapsulates and handles unsafety. As written, your ValueAction is likely annotated incorrectly, and Invoke needs to be marked as unsafe since the caller is responsible for making sure that the function pointer that was passed to Create is still alive.

[TahirAhmadov]

To be clear; yes, it will compile. However, the new unsafe rules don't mean you are free to go hog-wild, it means you are better able to express how your domain encapsulates and handles unsafety. As written, your ValueAction is likely annotated incorrectly, and Invoke needs to be marked as unsafe since the caller is responsible for making sure that the function pointer that was passed to Create is still alive.

Oh yes, that's what I meant by "properly tested etc." - the idea would be that it would be heavily guarded against unsafety. But I'm still not sure I want to switch to that "guarded unsafe" approach yet to squeeze out that performance increase. The code snippet above is purposefully simplified for the question I asked.

[333fred]

Sure, but even being purposefully simplified, I wanted to be clear that it is simplified to the point of being incorrectly annotated. Yes, it would be allowed, but it would also not be correct.