"Requires unsafe context" error in an unsafe iterator

[xparadoxical]

Version Used:
Compiler version: '4.12.0-3.24572.7 (dfa7fc6)'. Language version: 13.0.
Steps to Reproduce:
unsafe IEnumerable<int> M() { int* i = null; yield return 1; }
(sharplab)

Diagnostic Id:

CS0214: Pointers and fixed size buffers may only be used in an unsafe context

Expected Behavior:
Compiles, since the entire method is unsafe so pointers should be allowed without an explicit unsafe block.
Actual Behavior:
Doesn't compile, you have to use unsafe { int* i = null; }.

[huoyaoyuan]

It's intentional breaking change: https://github.com/dotnet/roslyn/blob/main/docs/compilers/CSharp/Compiler%20Breaking%20Changes%20-%20DotNet%209.md#iterators-introduce-safe-context-in-c-13-and-newer

According to the design note, unsafe on iterator method only introduces unsafe context on parameter and attribute declaration. The body is still safe context:

    [/* unsafe context */ A]
    unsafe IEnumerable<int> M3(
        /* unsafe context */ int*[] x)
    { // safe context
        yield return 1;
    }

[xparadoxical]

If an iterator declaration is marked with the unsafe modifier, the signature is in an unsafe scope but the iterator block used to implement that iterator still defines a safe scope.

Well that's sad. I thought my example should be equivalent to IEnumerable<int> M() { unsafe { int* i = null; } yield return 1; }, in other words yield returns which can't be in unsafe context would implicitly divide the unsafe context into smaller unsafe blocks. This doesn't seem to have been considered, looking at the 8th bullet point of the "alternatives" section. Unsafe blocks add a level of indentation, which is why I always prefer to mark entire members as unsafe.

[jcouv]

Thanks @huoyaoyuan for digging up the reference. This was indeed by design: "If an iterator declaration is marked with the unsafe modifier, the signature is in an unsafe scope but the iterator block used to implement that iterator still defines a safe scope."
But I don't recall the motivation for that choice. Tagging @jjonescz for comment. Thanks

[jjonescz]

But I don't recall the motivation for that choice.

The speclet has the motivation in https://github.com/dotnet/csharplang/blob/main/proposals/csharp-13.0/ref-unsafe-in-iterators-async.md#alternatives:

I thought my example should be equivalent to IEnumerable<int> M() { unsafe { int* i = null; } yield return 1; }, in other words yield returns which can't be in unsafe context would implicitly divide the unsafe context into smaller unsafe blocks. This doesn't seem to have been considered, looking at the 8th bullet point of the "alternatives" section.

That indeed wasn't considered (fwiw it looks like an overly complicated language rule to me), but feel free to open a discussion for that in https://github.com/dotnet/csharplang.