Added missing ValueTask (non-generic) to InProcess (no emit) toolchains.

Author: timcassell

src/BenchmarkDotNet/Toolchains/InProcess.NoEmit/BenchmarkActionFactory.cs

@@ -32,6 +32,9 @@ private static BenchmarkAction CreateCore(
             if (resultType == typeof(Task))
                 return new BenchmarkActionTask(resultInstance, targetMethod, unrollFactor);
 
+            if (resultType == typeof(ValueTask))
+                return new BenchmarkActionValueTask(resultInstance, targetMethod, unrollFactor);
+
             if (resultType.GetTypeInfo().IsGenericType)
             {
                 var genericType = resultType.GetGenericTypeDefinition();

src/BenchmarkDotNet/Toolchains/InProcess.NoEmit/BenchmarkActionFactory_Implementations.cs

@@ -150,6 +150,46 @@ private void InvokeMultipleHardcoded(long repeatCount)
             public override object LastRunResult => result;
         }
 
+        internal class BenchmarkActionValueTask : BenchmarkActionBase
+        {
+            private readonly Helpers.AwaitHelper awaitHelper = new Helpers.AwaitHelper();
+            private readonly Func<ValueTask> startTaskCallback;
+            private readonly Action callback;
+            private readonly Action unrolledCallback;
+
+            public BenchmarkActionValueTask(object instance, MethodInfo method, int unrollFactor)
+            {
+                bool isIdle = method == null;
+                if (!isIdle)
+                {
+                    startTaskCallback = CreateWorkload<Func<ValueTask>>(instance, method);
+                    callback = ExecuteBlocking;
+                }
+                else
+                {
+                    callback = Overhead;
+                }
+
+                InvokeSingle = callback;
+
+                unrolledCallback = Unroll(callback, unrollFactor);
+                InvokeMultiple = InvokeMultipleHardcoded;
+
+            }
+
+            // must be kept in sync with VoidDeclarationsProvider.IdleImplementation
+            private void Overhead() { }
+
+            // must be kept in sync with TaskDeclarationsProvider.TargetMethodDelegate
+            private void ExecuteBlocking() => awaitHelper.GetResult(startTaskCallback.Invoke());
+
+            private void InvokeMultipleHardcoded(long repeatCount)
+            {
+                for (long i = 0; i < repeatCount; i++)
+                    unrolledCallback();
+            }
+        }
+
         internal class BenchmarkActionValueTask<T> : BenchmarkActionBase
         {
             private readonly Helpers.AwaitHelper awaitHelper = new Helpers.AwaitHelper();

src/BenchmarkDotNet/Toolchains/InProcess/BenchmarkActionFactory.cs

@@ -34,6 +34,9 @@ private static BenchmarkAction CreateCore(
             if (resultType == typeof(Task))
                 return new BenchmarkActionTask(resultInstance, targetMethod, codegenMode, unrollFactor);
 
+            if (resultType == typeof(ValueTask))
+                return new BenchmarkActionValueTask(resultInstance, targetMethod, codegenMode, unrollFactor);
+
             if (resultType.GetTypeInfo().IsGenericType)
             {
                 var genericType = resultType.GetGenericTypeDefinition();

src/BenchmarkDotNet/Toolchains/InProcess/BenchmarkActionFactory_Implementations.cs

@@ -177,6 +177,52 @@ private void InvokeMultipleHardcoded(long repeatCount)
             public override object LastRunResult => result;
         }
 
+        internal class BenchmarkActionValueTask : BenchmarkActionBase
+        {
+            private readonly Helpers.AwaitHelper awaitHelper = new Helpers.AwaitHelper();
+            private readonly Func<ValueTask> startTaskCallback;
+            private readonly Action callback;
+            private readonly Action unrolledCallback;
+
+            public BenchmarkActionValueTask(object instance, MethodInfo method, BenchmarkActionCodegen codegenMode, int unrollFactor)
+            {
+                bool isIdle = method == null;
+                if (!isIdle)
+                {
+                    startTaskCallback = CreateWorkload<Func<ValueTask>>(instance, method);
+                    callback = ExecuteBlocking;
+                }
+                else
+                {
+                    callback = Overhead;
+                }
+
+                InvokeSingle = callback;
+
+                if (UseFallbackCode(codegenMode, unrollFactor))
+                {
+                    unrolledCallback = Unroll(callback, unrollFactor);
+                    InvokeMultiple = InvokeMultipleHardcoded;
+                }
+                else
+                {
+                    InvokeMultiple = EmitInvokeMultiple(this, nameof(callback), null, unrollFactor);
+                }
+            }
+
+            // must be kept in sync with VoidDeclarationsProvider.IdleImplementation
+            private void Overhead() { }
+
+            // must be kept in sync with TaskDeclarationsProvider.TargetMethodDelegate
+            private void ExecuteBlocking() => awaitHelper.GetResult(startTaskCallback.Invoke());
+
+            private void InvokeMultipleHardcoded(long repeatCount)
+            {
+                for (long i = 0; i < repeatCount; i++)
+                    unrolledCallback();
+            }
+        }
+
         internal class BenchmarkActionValueTask<T> : BenchmarkActionBase
         {
             private readonly Helpers.AwaitHelper awaitHelper = new Helpers.AwaitHelper();