Async refactor WIP

Author: timcassell

src/BenchmarkDotNet.Annotations/Attributes/AsyncCallerTypeAttribute.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace BenchmarkDotNet.Attributes;
+
+/// <summary>
+/// When applied to an async benchmark method, overrides the return type of the async method that calls the benchmark method.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method)]
+public sealed class AsyncCallerTypeAttribute(Type asyncCallerType) : Attribute
+{
+    /// <summary>
+    /// The return type of the async method that calls the benchmark method.
+    /// </summary>
+    public Type AsyncCallerType { get; private set; } = asyncCallerType;
+}

src/BenchmarkDotNet/Code/CodeGenerator.cs

@@ -31,29 +31,17 @@ internal static string Generate(BuildPartition buildPartition)
             {
                 var benchmark = buildInfo.BenchmarkCase;
 
-                var provider = GetDeclarationsProvider(benchmark.Descriptor);
-
-                string passArguments = GetPassArguments(benchmark);
-
-                string benchmarkTypeCode = new SmartStringBuilder(ResourceHelper.LoadTemplate("BenchmarkType.txt"))
+                string benchmarkTypeCode = GetDeclarationsProvider(benchmark)
+                    .ReplaceTemplate(new SmartStringBuilder(ResourceHelper.LoadTemplate("BenchmarkType.txt")))
                     .Replace("$ID$", buildInfo.Id.ToString())
-                    .Replace("$OperationsPerInvoke$", provider.OperationsPerInvoke)
-                    .Replace("$WorkloadTypeName$", provider.WorkloadTypeName)
-                    .Replace("$GlobalSetupMethodName$", provider.GlobalSetupMethodName)
-                    .Replace("$GlobalCleanupMethodName$", provider.GlobalCleanupMethodName)
-                    .Replace("$IterationSetupMethodName$", provider.IterationSetupMethodName)
-                    .Replace("$IterationCleanupMethodName$", provider.IterationCleanupMethodName)
                     .Replace("$JobSetDefinition$", GetJobsSetDefinition(benchmark))
                     .Replace("$ParamsContent$", GetParamsContent(benchmark))
                     .Replace("$ArgumentsDefinition$", GetArgumentsDefinition(benchmark))
                     .Replace("$DeclareArgumentFields$", GetDeclareArgumentFields(benchmark))
                     .Replace("$InitializeArgumentFields$", GetInitializeArgumentFields(benchmark))
-                    .Replace("$LoadArguments$", GetLoadArguments(benchmark))
-                    .Replace("$PassArguments$", passArguments)
                     .Replace("$EngineFactoryType$", GetEngineFactoryTypeName(benchmark))
                     .Replace("$RunExtraIteration$", buildInfo.Config.HasExtraIterationDiagnoser(benchmark) ? "true" : "false")
                     .Replace("$DisassemblerEntryMethodName$", DisassemblerConstants.DisassemblerEntryMethodName)
-                    .Replace("$WorkloadMethodCall$", provider.GetWorkloadMethodCall(passArguments))
                     .Replace("$InProcessDiagnoserRouters$", GetInProcessDiagnoserRouters(buildInfo))
                     .ToString();
 
@@ -122,27 +110,21 @@ private static string GetJobsSetDefinition(BenchmarkCase benchmarkCase)
                 Replace("; ", ";\n                ");
         }
 
-        private static DeclarationsProvider GetDeclarationsProvider(Descriptor descriptor)
+        private static DeclarationsProvider GetDeclarationsProvider(BenchmarkCase benchmark)
         {
-            var method = descriptor.WorkloadMethod;
+            var method = benchmark.Descriptor.WorkloadMethod;
 
-            if (method.ReturnType == typeof(Task) || method.ReturnType == typeof(ValueTask))
-            {
-                return new AsyncDeclarationsProvider(descriptor);
-            }
-            if (method.ReturnType.GetTypeInfo().IsGenericType
-                && (method.ReturnType.GetTypeInfo().GetGenericTypeDefinition() == typeof(Task<>)
-                    || method.ReturnType.GetTypeInfo().GetGenericTypeDefinition() == typeof(ValueTask<>)))
+            if (method.ReturnType.IsAwaitable())
             {
-                return new AsyncDeclarationsProvider(descriptor);
+                return new AsyncDeclarationsProvider(benchmark);
             }
 
             if (method.ReturnType == typeof(void) && method.HasAttribute<AsyncStateMachineAttribute>())
             {
                 throw new NotSupportedException("async void is not supported by design");
             }
 
-            return new SyncDeclarationsProvider(descriptor);
+            return new SyncDeclarationsProvider(benchmark);
         }
 
         // internal for tests
@@ -158,31 +140,19 @@ private static string GetArgumentsDefinition(BenchmarkCase benchmarkCase)
             => string.Join(
                 ", ",
                 benchmarkCase.Descriptor.WorkloadMethod.GetParameters()
-                         .Select((parameter, index) => $"{GetParameterModifier(parameter)} {parameter.ParameterType.GetCorrectCSharpTypeName()} arg{index}"));
+                    .Select((parameter, index) => $"{GetParameterModifier(parameter)} {parameter.ParameterType.GetCorrectCSharpTypeName()} arg{index}"));
 
         private static string GetDeclareArgumentFields(BenchmarkCase benchmarkCase)
             => string.Join(
                 Environment.NewLine,
                 benchmarkCase.Descriptor.WorkloadMethod.GetParameters()
-                         .Select((parameter, index) => $"private {GetFieldType(parameter.ParameterType, benchmarkCase.Parameters.GetArgument(parameter.Name)).GetCorrectCSharpTypeName()} __argField{index};"));
+                    .Select((parameter, index) => $"public {GetFieldType(parameter.ParameterType, benchmarkCase.Parameters.GetArgument(parameter.Name)).GetCorrectCSharpTypeName()} __argField{index};"));
 
         private static string GetInitializeArgumentFields(BenchmarkCase benchmarkCase)
             => string.Join(
                 Environment.NewLine,
                 benchmarkCase.Descriptor.WorkloadMethod.GetParameters()
-                    .Select((parameter, index) => $"this.__argField{index} = {benchmarkCase.Parameters.GetArgument(parameter.Name).ToSourceCode()};")); // we init the fields in ctor to provoke all possible allocations and overhead of other type
-
-        private static string GetLoadArguments(BenchmarkCase benchmarkCase)
-            => string.Join(
-                Environment.NewLine,
-                benchmarkCase.Descriptor.WorkloadMethod.GetParameters()
-                    .Select((parameter, index) => $"{(parameter.ParameterType.IsByRef ? "ref" : string.Empty)} {parameter.ParameterType.GetCorrectCSharpTypeName()} arg{index} = {(parameter.ParameterType.IsByRef ? "ref" : string.Empty)} this.__argField{index};"));
-
-        private static string GetPassArguments(BenchmarkCase benchmarkCase)
-            => string.Join(
-                ", ",
-                benchmarkCase.Descriptor.WorkloadMethod.GetParameters()
-                    .Select((parameter, index) => $"{GetParameterModifier(parameter)} arg{index}"));
+                    .Select((parameter, index) => $"this.__fieldsContainer.__argField{index} = {benchmarkCase.Parameters.GetArgument(parameter.Name).ToSourceCode()};")); // we init the fields in ctor to provoke all possible allocations and overhead of other type
 
         private static string GetExtraAttributes(BuildPartition buildPartition)
         {
@@ -236,7 +206,7 @@ private static string GetInProcessDiagnoserRouters(BenchmarkBuildInfo buildInfo)
             }
         }
 
-        private static string GetParameterModifier(ParameterInfo parameterInfo)
+        internal static string GetParameterModifier(ParameterInfo parameterInfo)
         {
             if (!parameterInfo.ParameterType.IsByRef)
                 return string.Empty;
@@ -260,28 +230,21 @@ private static Type GetFieldType(Type argumentType, ParameterInstance argument)
 
             return argumentType;
         }
+    }
 
-        private class SmartStringBuilder
-        {
-            private readonly string originalText;
-            private readonly StringBuilder builder;
-
-            public SmartStringBuilder(string text)
-            {
-                originalText = text;
-                builder = new StringBuilder(text);
-            }
-
-            public SmartStringBuilder Replace(string oldValue, string? newValue)
-            {
-                if (originalText.Contains(oldValue))
-                    builder.Replace(oldValue, newValue);
-                else
-                    builder.Append($"\n// '{oldValue}' not found");
-                return this;
-            }
+    internal class SmartStringBuilder(string text)
+    {
+        private readonly StringBuilder builder = new(text);
 
-            public override string ToString() => builder.ToString();
+        public SmartStringBuilder Replace(string oldValue, string? newValue)
+        {
+            if (text.Contains(oldValue))
+                builder.Replace(oldValue, newValue);
+            else
+                builder.Append($"\n// '{oldValue}' not found");
+            return this;
         }
+
+        public override string ToString() => builder.ToString();
     }
 }