runtime-async

AssemblyToProcess/AssemblyToProcess.csproj

@@ -1,10 +1,15 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>net472;net6.0</TargetFrameworks>
+    <TargetFrameworks>net472;net10.0;net11.0</TargetFrameworks>
     <DisableFody>true</DisableFody>
     <Nullable>enable</Nullable>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(TargetFramework)'=='net11.0'">
+    <EnablePreviewFeatures>true</EnablePreviewFeatures>
+    <Features>$(Features);runtime-async=on</Features>
+    <DefineConstants>$(DefineConstants);NET11_0</DefineConstants>
+  </PropertyGroup>
   <ItemGroup>
     <Using Remove="System.Net.Http" />
     <ProjectReference Include="..\ConfigureAwait\ConfigureAwait.csproj" />

AssemblyToProcess/CatchAndFinally.cs

@@ -76,7 +76,7 @@ public async Task Finally3()
         }
     }
 
-#if NETCOREAPP2_0
+#if NET
         public async Task Catch1_WithValueTask()
         {
             try

AssemblyToProcess/ClassWithAttribute.cs

@@ -19,16 +19,16 @@ public async Task<int> AsyncMethodWithReturn(SynchronizationContext context)
     public async Task AsyncGenericMethod(SynchronizationContext context)
     {
         SynchronizationContext.SetSynchronizationContext(context);
-        await Task.Run(() => 10);
+        await Task.Run(async () => await Return10());
     }
 
     public async Task<int> AsyncGenericMethodWithReturn(SynchronizationContext context)
     {
         SynchronizationContext.SetSynchronizationContext(context);
-        return await Task.Run(() => 10);
+        return await Task.Run(async () => await Return10());
     }
 
-#if NETCOREAPP2_0
+#if NET
     public async Task AsyncMethod_WithValueTask(SynchronizationContext context)
     {
         SynchronizationContext.SetSynchronizationContext(context);
@@ -45,13 +45,20 @@ public async Task<int> AsyncMethodWithReturn_WithValueTask(SynchronizationContex
     public async Task AsyncGenericMethod_WithValueTask(SynchronizationContext context)
     {
         SynchronizationContext.SetSynchronizationContext(context);
-        await new ValueTask(Task.Run(() => 10));
+        await new ValueTask(Task.Run(async () => await Return10()));
     }
 
     public async Task<int> AsyncGenericMethodWithReturn_WithValueTask(SynchronizationContext context)
     {
         SynchronizationContext.SetSynchronizationContext(context);
-        return await new ValueTask<int>(Task.Run(() => 10));
+        return await new ValueTask<int>(Task.Run(async () => await Return10()));
     }
 #endif
+
+    // using some more complex task than async () => 10, to make sure the method is not optimized away by the compiler, which would make the test fail;
+    async Task<int> Return10()
+    {
+        await Task.Delay(10).ConfigureAwait(false);
+        return 10;
+    }
 }

AssemblyToProcess/DoNotWeave.cs

@@ -19,16 +19,16 @@ public async Task<int> AsyncMethodWithReturn(SynchronizationContext context)
     public async Task AsyncGenericMethod(SynchronizationContext context)
     {
         SynchronizationContext.SetSynchronizationContext(context);
-        await Task.Run(() => 10).ConfigureAwait(true);
+        await Task.Run(async () => await Return10()).ConfigureAwait(true);
     }
 
     public async Task<int> AsyncGenericMethodWithReturn(SynchronizationContext context)
     {
         SynchronizationContext.SetSynchronizationContext(context);
-        return await Task.Run(() => 10).ConfigureAwait(true);
+        return await Task.Run(async () => await Return10()).ConfigureAwait(true);
     }
 
-#if NETCOREAPP2_0
+#if NET
     public async Task AsyncMethod_WithValueTask(SynchronizationContext context)
     {
         SynchronizationContext.SetSynchronizationContext(context);
@@ -45,13 +45,21 @@ public async Task<int> AsyncMethodWithReturn_WithValueTask(SynchronizationContex
     public async Task AsyncGenericMethod_WithValueTask(SynchronizationContext context)
     {
         SynchronizationContext.SetSynchronizationContext(context);
-        await new ValueTask(Task.Run(() => 10)).ConfigureAwait(true);
+        await new ValueTask(Task.Run(async () => await Return10())).ConfigureAwait(true);
     }
 
     public async Task<int> AsyncGenericMethodWithReturn_WithValueTask(SynchronizationContext context)
     {
         SynchronizationContext.SetSynchronizationContext(context);
-        return await new ValueTask<int>(Task.Run(() => 10)).ConfigureAwait(true);
+        return await new ValueTask<int>(Task.Run(async () => await Return10())).ConfigureAwait(true);
     }
+
 #endif
+
+    // using some more complex task than () => 10, to make sure the method is not optimized away by the compiler, which would make the test fail;
+    async Task<int> Return10()
+    {
+        await Task.Delay(10).ConfigureAwait(false);
+        return 10;
+    }
 }

AssemblyToProcess/Example.cs

@@ -93,7 +93,7 @@ public async Task<Example> AsyncMethod12()
         return result;
     }
 
-#if NETCOREAPP2_0
+#if NET
     public async Task AsyncMethod1_WithValueTask()
     {
         await new ValueTask(Task.Delay(1));

AssemblyToProcess/FlagSynchronizationContext.cs

@@ -1,5 +1,4 @@
-public class FlagSynchronizationContext :
-    SynchronizationContext
+public class FlagSynchronizationContext : SynchronizationContext
 {
     public bool Flag { get; set; }
 

AssemblyToProcess/GenericIssue.cs

@@ -9,7 +9,7 @@ public async Task Method(Task<TItem> itemTask)
         var item = await itemTask;
     }
 
-#if NETCOREAPP2_0
+#if NET
     [ConfigureAwait(false)]
     public async Task Method_WithValueTask(Task<TItem> itemTask)
     {
@@ -26,7 +26,7 @@ public async Task Method<TItem>(Task<TItem> itemTask)
         var item = await itemTask;
     }
 
-#if NETCOREAPP2_0
+#if NET
     [ConfigureAwait(false)]
     public async Task Method_WithValueTask<TItem>(Task<TItem> itemTask)
     {

AssemblyToProcess/Issue1.cs

@@ -11,11 +11,11 @@ async Task WithReaderAndWriter(TextWriter writer, StreamReader reader)
         }
     }
 
-#if NETCOREAPP2_0
+#if NET
     [ConfigureAwait(false)]
     async Task WithReaderAndWriter_WithValueTask(TextWriter writer, StreamReader reader)
     {
-        while (await new ValueTask<string>(reader.ReadLineAsync()) is { } line)
+        while (await new ValueTask<string?>(reader.ReadLineAsync()) is { } line)
         {
             await new ValueTask(writer.WriteLineAsync(line));
         }

AssemblyToProcess/MethodWithAttribute.cs

@@ -9,7 +9,7 @@ public async Task AsyncMethod(SynchronizationContext context)
         await Task.Delay(0);
     }
 
-#if NETCOREAPP2_0
+#if NET
     [ConfigureAwait(false)]
     public async Task AsyncMethod_WithValueTask(SynchronizationContext context)
     {

AssemblyToProcess/MethodWithUsing.cs

@@ -14,7 +14,7 @@ static async Task<IDisposable> NewMethod()
         return new MyDisposable();
     }
 
-#if NETCOREAPP2_0
+#if NET
     [ConfigureAwait(false)]
     public async Task AsyncMethod_WithValueTask()
     {

ConfigureAwait.Fody/CecilExtensions.cs

@@ -2,8 +2,18 @@
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 
+enum AsyncStateMachineKind
+{
+    None,
+    StateMachine,
+    CompilerService
+}
+
 static class CecilExtensions
 {
+    // Not yet defined in Cecil, remove later when update is available.
+    const MethodImplAttributes MethodImplAttributes_Async = (MethodImplAttributes)0x2000;
+
     public static bool IsIAsyncStateMachine(this TypeDefinition type)
     {
         if (type is not {HasInterfaces: true})
@@ -12,12 +22,12 @@ public static bool IsIAsyncStateMachine(this TypeDefinition type)
         }
 
         return type.Interfaces
-            .Any(_ => _.InterfaceType.FullName == "System.Runtime.CompilerServices.IAsyncStateMachine");
+            .Any(item => item.InterfaceType.FullName == "System.Runtime.CompilerServices.IAsyncStateMachine");
     }
 
     public static MethodDefinition Method(this TypeDefinition type, MethodReference reference)
     {
-        return type.Methods.FirstOrDefault(_ => _.Name == reference.Name);
+        return type.Methods.FirstOrDefault(item => item.Name == reference.Name);
     }
 
     public static bool IsCompilerGenerated(this ICustomAttributeProvider provider)
@@ -39,10 +49,15 @@ public static void InsertBefore(this ILProcessor processor, Instruction target,
         }
     }
 
-    public static bool IsAsyncStateMachineType(this ICustomAttributeProvider provider)
+    public static AsyncStateMachineKind GetAsyncStateMachineKind(this MethodDefinition method)
     {
-        return provider.CustomAttributes
-            .Any(a => a.AttributeType.FullName == "System.Runtime.CompilerServices.AsyncStateMachineAttribute");
+        if (method.CustomAttributes.Any(a => a.AttributeType.FullName == "System.Runtime.CompilerServices.AsyncStateMachineAttribute"))
+            return AsyncStateMachineKind.StateMachine;
+
+        if (method.ImplAttributes.HasFlag(MethodImplAttributes_Async))
+            return AsyncStateMachineKind.CompilerService;
+
+        return AsyncStateMachineKind.None;
     }
 
     public static TypeDefinition GetAsyncStateMachineType(this ICustomAttributeProvider provider)
@@ -53,7 +68,7 @@ public static TypeDefinition GetAsyncStateMachineType(this ICustomAttributeProvi
         return (TypeDefinition)attribute?.ConstructorArguments[0].Value;
     }
 
-    public static CustomAttribute GetConfigureAwaitAttribute(this ICustomAttributeProvider value)
+    static CustomAttribute GetConfigureAwaitAttribute(this ICustomAttributeProvider value)
     {
         return value.CustomAttributes.FirstOrDefault(a => a.AttributeType.FullName == "Fody.ConfigureAwaitAttribute");
     }
@@ -66,11 +81,11 @@ public static CustomAttribute GetConfigureAwaitAttribute(this ICustomAttributePr
             return defaultValue;
         }
 
-        if (value is MethodDefinition method &&
-            !method.IsAsyncStateMachineType())
+        if (value is MethodDefinition method && method.GetAsyncStateMachineKind() == AsyncStateMachineKind.None)
         {
             throw new WeavingException($"ConfigureAwaitAttribute applied to non-async method '{method.FullName}'.");
         }
+
         return (bool?)attribute.ConstructorArguments[0].Value;
     }
 

ConfigureAwait.Fody/ConfigureAwait.Fody.csproj

@@ -6,6 +6,6 @@
   </PropertyGroup>
   <ItemGroup>
     <Using Remove="System.Net.Http" />
-    <PackageReference Include="FodyHelpers" Version="6.8.0" />
+    <PackageReference Include="FodyHelpers" Version="6.9.3" />
   </ItemGroup>
 </Project>

ConfigureAwait.Fody/ModuleWeaver.cs

@@ -10,7 +10,7 @@ public override void Execute()
     {
         ReadConfig();
 
-        FindTypes();
+        FindRuntimeTypes();
 
         var configureAwaitValue = ModuleDefinition.Assembly.GetConfigureAwaitConfig(continueOnCapturedContext);
 
@@ -51,20 +51,23 @@ void ProcessType(bool? assemblyConfigureAwaitValue, TypeDefinition type)
             return;
         }
 
-        var configureAwaitValue = type.GetConfigureAwaitConfig(assemblyConfigureAwaitValue);
+        var typeConfigureAwaitValue = type.GetConfigureAwaitConfig(assemblyConfigureAwaitValue);
 
         foreach (var method in type.Methods)
         {
-            var localConfigureAwaitValue = method.GetConfigureAwaitConfig(configureAwaitValue);
-            if (localConfigureAwaitValue == null)
-            {
+            var methodConfigureAwaitValue = method.GetConfigureAwaitConfig(typeConfigureAwaitValue);
+
+            if (!methodConfigureAwaitValue.HasValue)
                 continue;
-            }
 
             var asyncStateMachineType = method.GetAsyncStateMachineType();
             if (asyncStateMachineType != null)
             {
-                AddAwaitConfigToAsyncMethod(asyncStateMachineType, localConfigureAwaitValue.Value);
+                AddAwaitConfigToAsyncMethod(asyncStateMachineType, methodConfigureAwaitValue.Value);
+            }
+            else if (method.GetAsyncStateMachineKind() == AsyncStateMachineKind.CompilerService)
+            {
+                AddAwaitConfigToAsyncMethod(method, methodConfigureAwaitValue.Value);
             }
         }
     }
@@ -114,6 +117,10 @@ void TryRedirectMethodInstruction(MethodReference method, Instruction instructio
         var declaringType = method.DeclaringType;
         if (declaringType.FullName == "System.Threading.Tasks.Task")
         {
+            // Only redirect GetAwaiter; constructors and other members must not be redirected
+            if (method.Name != "GetAwaiter")
+                return;
+
             var newOperand = configuredTaskAwaitableTypeDef.Method(method);
             if (newOperand != null)
             {
@@ -126,6 +133,10 @@ void TryRedirectMethodInstruction(MethodReference method, Instruction instructio
 
         if (declaringType.FullName == "System.Threading.Tasks.ValueTask")
         {
+            // Only redirect GetAwaiter; constructors and other members must not be redirected
+            if (method.Name != "GetAwaiter")
+                return;
+
             var newOperand = configuredValueTaskAwaitableTypeDef.Method(method);
             if (newOperand != null)
             {
@@ -168,6 +179,10 @@ void TryRedirectMethodInstruction(MethodReference method, Instruction instructio
             // Change Task`1 to ConfiguredTaskAwaitable`1
             if (declaringType.FullName.StartsWith("System.Threading.Tasks.Task`1"))
             {
+                // Only redirect GetAwaiter; other members (including constructors) must not be redirected
+                if (method.Name != "GetAwaiter")
+                    return;
+
                 var newOperand = genericConfiguredTaskAwaitableTypeDef.Method(method);
                 if (newOperand != null)
                 {
@@ -183,6 +198,10 @@ void TryRedirectMethodInstruction(MethodReference method, Instruction instructio
             // Change Task`1 to ConfiguredTaskAwaitable`1
             if (declaringType.FullName.StartsWith("System.Threading.Tasks.ValueTask`1"))
             {
+                // Only redirect GetAwaiter; other members (including constructors) must not be redirected
+                if (method.Name != "GetAwaiter")
+                    return;
+
                 var newOperand = genericConfiguredValueTaskAwaitableTypeDef.Method(method);
                 if (newOperand != null)
                 {