InProcessNoEmitToolchain changes:

- Overhead matches workload return type.
- Use Consumer instead of writing to generic field.
- Added support for pointer, ByRef, and ValueTask returns.

src/BenchmarkDotNet/Extensions/ReflectionExtensions.cs

@@ -185,9 +185,7 @@ internal static bool IsStackOnlyWithImplicitCast(this Type argumentType, object?
             if (argumentInstance == null)
                 return false;
 
-            // IsByRefLikeAttribute is not exposed for older runtimes, so we need to check it in an ugly way ;)
-            bool isByRefLike = argumentType.GetCustomAttributes().Any(attribute => attribute.ToString()?.Contains("IsByRefLike") ?? false);
-            if (!isByRefLike)
+            if (!argumentType.IsByRefLike())
                 return false;
 
             var instanceType = argumentInstance.GetType();
@@ -209,5 +207,9 @@ private static bool IsRunnableGenericType(TypeInfo typeInfo)
                     && typeInfo.DeclaredConstructors.Any(ctor => ctor.IsPublic && ctor.GetParameters().Length == 0); // we need public parameterless ctor to create it
 
         internal static bool IsLinqPad(this Assembly assembly) => assembly.FullName.IndexOf("LINQPAD", StringComparison.OrdinalIgnoreCase) >= 0;
+
+        internal static bool IsByRefLike(this Type type)
+            // Type.IsByRefLike is not available in netstandard2.0.
+            => type.IsValueType && type.CustomAttributes.Any(attr => attr.AttributeType.FullName == "System.Runtime.CompilerServices.IsByRefLikeAttribute");
     }
 }

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

@@ -1,11 +1,8 @@
 using System;
 
-using JetBrains.Annotations;
-
 namespace BenchmarkDotNet.Toolchains.InProcess.NoEmit
 {
     /// <summary>Common API to run the Setup/Clean/Idle/Run methods</summary>
-    [PublicAPI]
     public abstract class BenchmarkAction
     {
         /// <summary>Gets or sets invoke single callback.</summary>
@@ -16,8 +13,7 @@ public abstract class BenchmarkAction
         /// <value>Invoke multiple times callback.</value>
         public Action<long> InvokeMultiple { get; protected set; }
 
-        /// <summary>Gets the last run result.</summary>
-        /// <value>The last run result.</value>
-        public virtual object LastRunResult => null;
+        [Obsolete("The result is no longer stored past the iteration.", true)]
+        public object LastRunResult => null;
     }
 }

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

@@ -1,13 +1,12 @@
 using System;
+using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Running;
 
-using JetBrains.Annotations;
-
 namespace BenchmarkDotNet.Toolchains.InProcess.NoEmit
 {
     /// <summary>Helper class that creates <see cref="BenchmarkAction"/> instances. </summary>
@@ -29,9 +28,40 @@ private static BenchmarkAction CreateCore(
             if (resultType == typeof(void))
                 return new BenchmarkActionVoid(resultInstance, targetMethod, unrollFactor);
 
+            if (resultType == typeof(void*))
+                return new BenchmarkActionVoidPointer(resultInstance, targetMethod, unrollFactor);
+
+            if (resultType.IsPointer)
+                return Create(
+                    typeof(BenchmarkActionPointer<>).MakeGenericType(resultType.GetElementType()),
+                    resultInstance,
+                    targetMethod,
+                    unrollFactor);
+
+            if (resultType.IsByRef)
+            {
+                var returnParameter = targetMethod?.ReturnParameter ?? fallbackIdleSignature.ReturnParameter;
+                // System.Runtime.CompilerServices.IsReadOnlyAttribute is part of .NET Standard 2.1, we can't use it here..
+                if (returnParameter.GetCustomAttributes().Any(attribute => attribute.GetType().Name == "IsReadOnlyAttribute"))
+                    return Create(
+                        typeof(BenchmarkActionByRefReadonly<>).MakeGenericType(resultType.GetElementType()),
+                        resultInstance,
+                        targetMethod,
+                        unrollFactor);
+
+                return Create(
+                        typeof(BenchmarkActionByRef<>).MakeGenericType(resultType.GetElementType()),
+                        resultInstance,
+                        targetMethod,
+                        unrollFactor);
+            }
+
             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();
@@ -51,10 +81,6 @@ private static BenchmarkAction CreateCore(
                         unrollFactor);
             }
 
-            if (targetMethod == null && resultType.GetTypeInfo().IsValueType)
-                // for Idle: we return int because creating bigger ValueType could take longer than benchmarked method itself.
-                resultType = typeof(int);
-
             return Create(
                 typeof(BenchmarkAction<>).MakeGenericType(resultType),
                 resultInstance,
@@ -88,6 +114,10 @@ private static void PrepareInstanceAndResultType(
                 if (isUsingAsyncKeyword)
                     throw new NotSupportedException("Async void is not supported by design.");
             }
+            else if (resultType.IsByRefLike())
+            {
+                throw new NotSupportedException("InProcessNoEmitToolchain does not support consuming ByRefLike return types.");
+            }
         }
 
         /// <summary>Helper to enforce .ctor signature.</summary>