#12: Add support for shimming async methods

README.md

@@ -185,6 +185,66 @@ Shimming of the following operators is not supported:
 - `x >>> y` because expression trees cannot contain this operator. This is a limitation on the part of the compiler.
 - `++` and `--` because these cannot be expressed in an expression tree.
 
+## Async usage
+### Shim static async method
+```csharp
+using Pose;
+
+Shim staticTaskShim = Shim.Replace(() => DoWorkAsync()).With(
+    delegate
+    {
+        Console.Write("refusing to do work");
+        return Task.CompletedTask;
+    });
+```
+
+### Shim async instance method of a Reference Type
+```csharp
+using Pose;
+
+Shim instanceTaskShim = Shim.Replace(() => Is.A<MyClass>().DoSomethingAsync()).With(
+    delegate(MyClass @this)
+    {
+        Console.WriteLine("doing something else async");
+        return Task.CompletedTask;
+    });
+```
+
+### Shim method of specific instance of a Reference Type
+_Not supported for now. When supported, however, it will look like the following._
+
+```csharp
+using Pose;
+
+MyClass myClass = new MyClass();
+Shim myClassTaskShim = Shim.Replace(() => myClass.DoSomethingAsync()).With(
+    delegate(MyClass @this)
+    {
+        Console.WriteLine("doing something else with myClass async");
+        return Task.CompletedTask;
+    });
+```
+
+### Isolating your async code
+
+```csharp
+// This block executes immediately
+await PoseContext.Isolate(async () =>
+{
+    // All code that executes within this block
+    // is isolated and shimmed methods are replaced
+
+    // Outputs "refusing to do work"
+    await DoWorkAsync();
+
+    // Outputs "doing something else async"
+    new MyClass().DoSomethingAsync();
+
+    // Outputs "doing something else with myClass async"
+    await myClass.DoSomethingAsync();
+
+}, staticTaskShim, instanceTaskShim, myClassTaskShim);
+```
 ## Caveats & Limitations
 
 * **Breakpoints** - At this time any breakpoints set anywhere in the isolated code and its execution path will not be hit. However, breakpoints set within a shim replacement delegate are hit.

src/Pose/Extensions/TypeExtensions.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace Pose.Extensions
+{
+    internal static class TypeExtensions
+    {
+        public static bool ImplementsInterface<TInterface>(this Type type)
+        {
+            if (type == null) throw new ArgumentNullException(nameof(type));
+            if (!typeof(TInterface).IsInterface) throw new InvalidOperationException($"{typeof(TInterface)} is not an interface.");
+
+            return type.GetInterfaces().Any(interfaceType => interfaceType == typeof(TInterface));
+        }
+
+        public static bool HasAttribute<TAttribute>(this Type type) where TAttribute : Attribute
+        {
+            if (type == null) throw new ArgumentNullException(nameof(type));
+
+            var compilerGeneratedAttribute = type.GetCustomAttribute<TAttribute>() ?? type.ReflectedType?.GetCustomAttribute<TAttribute>();
+
+            return compilerGeneratedAttribute != null;
+        }
+
+        public static MethodInfo GetExplicitlyImplementedMethod<TInterface>(this Type type, string methodName)
+        {
+            if (type == null) throw new ArgumentNullException(nameof(type));
+            if (string.IsNullOrWhiteSpace(methodName)) throw new ArgumentException("Value cannot be null or whitespace.", nameof(methodName));
+
+            var interfaceType = type.GetInterfaceType<TInterface>() ?? throw new Exception();
+            var method = interfaceType.GetMethod(methodName) ?? throw new Exception();
+            var methodDeclaringType = method.DeclaringType ?? throw new Exception($"The {methodName} method does not have a declaring type");
+            var interfaceMapping = type.GetInterfaceMap(methodDeclaringType);
+            var requestedTargetMethod = interfaceMapping.TargetMethods.FirstOrDefault(m => m.Name == methodName);
+
+            return requestedTargetMethod;
+        }
+
+        private static Type GetInterfaceType<TInterface>(this Type type)
+        {
+            if (type == null) throw new ArgumentNullException(nameof(type));
+            if (!typeof(TInterface).IsInterface) throw new InvalidOperationException($"{typeof(TInterface)} is not an interface.");
+
+            return type.GetInterfaces().FirstOrDefault(interfaceType => interfaceType == typeof(TInterface));
+        }
+
+        public static bool IsAsync(this Type thisType)
+        {
+            if (thisType == null) throw new ArgumentNullException(nameof(thisType));
+
+            return
+                // State machines are generated by the compiler...
+                thisType.HasAttribute<CompilerGeneratedAttribute>()
+
+                // as nested private classes...
+                && thisType.IsNestedPrivate
+
+                // which implements IAsyncStateMachine. 
+                && thisType.ImplementsInterface<IAsyncStateMachine>();
+        }
+    }
+}

src/Pose/Helpers/StubHelper.cs

@@ -2,7 +2,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
-
+using System.Runtime.CompilerServices;
 using Pose.Extensions;
 
 namespace Pose.Helpers
@@ -58,6 +58,11 @@ public static MethodInfo DeVirtualizeMethod(Type thisType, MethodInfo virtualMet
 
             var bindingFlags = BindingFlags.Instance | (virtualMethod.IsPublic ? BindingFlags.Public : BindingFlags.NonPublic);
             var types = virtualMethod.GetParameters().Select(p => p.ParameterType).ToArray();
+
+            if (thisType.IsAsync())
+            {
+                return thisType.GetExplicitlyImplementedMethod<IAsyncStateMachine>(nameof(IAsyncStateMachine.MoveNext));
+            }
 
             return thisType.GetMethod(virtualMethod.Name, bindingFlags, null, types, null);
         }
@@ -94,11 +99,7 @@ public static string CreateStubNameFromMethod(string prefix, MethodBase method)
                 if (genericArguments.Length > 0)
                 {
                     name += "[";
-#if NETSTANDARD2_1_OR_GREATER
-                    name += string.Join(',', genericArguments.Select(g => g.Name));
-#else
                     name += string.Join(",", genericArguments.Select(g => g.Name));
-#endif
                     name += "]";
                 }
             }