Weave async iterator methods (#624, #597)

Async iterators (async IAsyncEnumerable<T> with yield) are lowered with
AsyncIteratorStateMachineAttribute rather than AsyncStateMachineAttribute,
so ProcessType skipped them and their awaits kept resuming on the captured
context. Recognise both attributes in GetAsyncStateMachineKind/Type so the
iterator body is woven like any other state machine.
Adds behavioural tests for the iterator producer plus the await foreach /
await using consumer paths, and an IL snapshot of the woven types.

Author: SimonCropp

AssemblyToProcess/AsyncEnumerable.cs

@@ -0,0 +1,59 @@
+#if NET
+using Fody;
+
+[ConfigureAwait(false)]
+public class AsyncEnumerable
+{
+    // Issue #624: an async iterator method (lowered with AsyncIteratorStateMachineAttribute)
+    // must have its internal awaits configured. The only await here is the unconfigured
+    // Task.Delay, so the flag reflects whether the iterator body was woven.
+    public async IAsyncEnumerable<int> Producer(SynchronizationContext context)
+    {
+        SynchronizationContext.SetSynchronizationContext(context);
+        await Task.Delay(10);
+        yield return 1;
+        await Task.Delay(10);
+        yield return 2;
+    }
+
+    // Issue #597: consuming an IAsyncEnumerable<T> with `await foreach` awaits the
+    // ValueTask<bool>/ValueTask returned by MoveNextAsync/DisposeAsync. The source's own
+    // await is configured explicitly so only this consumer's awaits are under test.
+    public async Task AwaitForeach(SynchronizationContext context)
+    {
+        SynchronizationContext.SetSynchronizationContext(context);
+        // ReSharper disable once UnusedVariable
+        await foreach (var item in Source())
+        {
+        }
+    }
+
+    static async IAsyncEnumerable<int> Source()
+    {
+        await Task.Delay(10).ConfigureAwait(false);
+        yield return 1;
+    }
+
+    // Issue #597: consuming an IAsyncDisposable with `await using` awaits the ValueTask
+    // returned by DisposeAsync. The disposable's own await is configured explicitly so
+    // only this consumer's await is under test.
+    public async Task AwaitUsing(SynchronizationContext context)
+    {
+        SynchronizationContext.SetSynchronizationContext(context);
+        await using (new AsyncDisposable())
+        {
+        }
+    }
+}
+
+public class AsyncDisposable : IAsyncDisposable
+{
+    public async ValueTask DisposeAsync()
+    {
+        await Task.Delay(10).ConfigureAwait(false);
+        Disposed = true;
+    }
+
+    public static bool Disposed;
+}
+#endif

ConfigureAwait.Fody/CecilExtensions.cs

@@ -49,9 +49,20 @@ public static void InsertBefore(this ILProcessor processor, Instruction target,
         }
     }
 
+    // Async iterators (async IAsyncEnumerable<T> with yield) are lowered to a state machine
+    // just like normal async methods, but the generated method carries
+    // AsyncIteratorStateMachineAttribute rather than AsyncStateMachineAttribute.
+    static bool IsAsyncStateMachineAttribute(this CustomAttribute attribute)
+    {
+        var fullName = attribute.AttributeType.FullName;
+        return fullName is
+            "System.Runtime.CompilerServices.AsyncStateMachineAttribute" or
+            "System.Runtime.CompilerServices.AsyncIteratorStateMachineAttribute";
+    }
+
     public static AsyncStateMachineKind GetAsyncStateMachineKind(this MethodDefinition method)
     {
-        if (method.CustomAttributes.Any(a => a.AttributeType.FullName == "System.Runtime.CompilerServices.AsyncStateMachineAttribute"))
+        if (method.CustomAttributes.Any(IsAsyncStateMachineAttribute))
             return AsyncStateMachineKind.StateMachine;
 
         if (method.ImplAttributes.HasFlag(MethodImplAttributes_Async))
@@ -63,7 +74,7 @@ public static AsyncStateMachineKind GetAsyncStateMachineKind(this MethodDefiniti
     public static TypeDefinition GetAsyncStateMachineType(this ICustomAttributeProvider provider)
     {
         var attribute = provider.CustomAttributes
-            .FirstOrDefault(a => a.AttributeType.FullName == "System.Runtime.CompilerServices.AsyncStateMachineAttribute");
+            .FirstOrDefault(IsAsyncStateMachineAttribute);
 
         return (TypeDefinition)attribute?.ConstructorArguments[0].Value;
     }

Tests/AsyncEnumerableTests.cs

@@ -0,0 +1,51 @@
+#if NET
+public partial class ModuleWeaverTests
+{
+    // Issue #624: the async iterator body must be woven so its awaits do not resume on
+    // the captured context.
+    [Fact]
+    public async Task AsyncEnumerable_Producer()
+    {
+        var context = testResult.GetInstance("FlagSynchronizationContext");
+        var test = testResult.GetInstance("AsyncEnumerable");
+
+        Assert.False(context.Flag);
+
+        var enumerable = (IAsyncEnumerable<int>)test.Producer(context);
+        // ReSharper disable once UnusedVariable
+        await foreach (var item in enumerable)
+        {
+        }
+
+        Assert.False(context.Flag);
+    }
+
+    // Issue #597: `await foreach` over an IAsyncEnumerable<T>.
+    [Fact]
+    public async Task AsyncEnumerable_AwaitForeach()
+    {
+        var context = testResult.GetInstance("FlagSynchronizationContext");
+        var test = testResult.GetInstance("AsyncEnumerable");
+
+        Assert.False(context.Flag);
+
+        await test.AwaitForeach(context);
+
+        Assert.False(context.Flag);
+    }
+
+    // Issue #597: `await using` over an IAsyncDisposable.
+    [Fact]
+    public async Task AsyncEnumerable_AwaitUsing()
+    {
+        var context = testResult.GetInstance("FlagSynchronizationContext");
+        var test = testResult.GetInstance("AsyncEnumerable");
+
+        Assert.False(context.Flag);
+
+        await test.AwaitUsing(context);
+
+        Assert.False(context.Flag);
+    }
+}
+#endif