#12 Clean up implementation

src/Pose/Extensions/TypeExtensions.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Linq;
+using System.Reflection;
+
+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));
+        }
+    }
+}

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,18 +58,28 @@ 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.IsNestedPrivate && thisType.GetInterfaces().Any(i => i.Name == "IAsyncStateMachine"))
-            {
-                var nestedType = thisType;
-                var targetMethod = nestedType.GetInterfaceMap(nestedType.GetInterfaces()[0].GetMethod("MoveNext").DeclaringType).TargetMethods[0];
 
-                return targetMethod;
+            if (IsAsync(thisType))
+            {
+                return thisType.GetExplicitlyImplementedMethod<IAsyncStateMachine>(nameof(IAsyncStateMachine.MoveNext));
             }
 
             return thisType.GetMethod(virtualMethod.Name, bindingFlags, null, types, null);
         }
 
+        private static bool IsAsync(Type thisType)
+        {
+            return
+                // State machines are generated by the compiler...
+                thisType.HasAttribute<CompilerGeneratedAttribute>()
+
+                // as nested private classes...
+                && thisType.IsNestedPrivate
+
+                // which implements IAsyncStateMachine. 
+                && thisType.ImplementsInterface<IAsyncStateMachine>();
+        }
+
         public static Module GetOwningModule() => typeof(StubHelper).Module;
 
         public static bool IsIntrinsic(MethodBase method)