Only use default for types that cannot be passed to generic function (ByRefLike and pointers), use Unsafe.SkipInit for everything else.

Check for pointer type when setting default local in InProcessEmitToolchain.

Author: timcassell

src/BenchmarkDotNet/Code/DeclarationsProvider.cs

@@ -90,8 +90,8 @@ public override string OverheadImplementation
             get
             {
                 var type = WorkloadMethodReturnType;
-                bool isByRefLike = type.IsByRefLike();
-                if (isByRefLike || (Consumer.IsConsumable(type) && !isByRefLike))
+                // ByRefLike types and pointers use default, everything else uses Unsafe.SkipInit.
+                if (type.IsByRefLike() || type.IsPointer)
                 {
                     return $"return default({type.GetCorrectCSharpTypeName()});";
                 }

src/BenchmarkDotNet/Engines/Consumer.cs

@@ -12,13 +12,6 @@ namespace BenchmarkDotNet.Engines
 {
     public class Consumer
     {
-        private static readonly HashSet<Type> SupportedTypes
-            = new HashSet<Type>(
-                typeof(Consumer).GetTypeInfo()
-                                .DeclaredFields
-                                .Where(field => !field.IsStatic) // exclude this HashSet itself
-                                .Select(field => field.FieldType));
-
 #pragma warning disable IDE0052 // Remove unread private members
         private volatile byte byteHolder;
         private volatile sbyte sbyteHolder;
@@ -130,9 +123,7 @@ public void Consume<T>(in T value)
             // This also works for empty structs, because the runtime enforces a minimum size of 1 byte.
             => byteHolder = Unsafe.As<T, byte>(ref Unsafe.AsRef(in value));
 
-        internal static bool IsConsumable(Type type)
-            // IsClass returns true for pointers.
-            => SupportedTypes.Contains(type) || type.GetTypeInfo().IsClass || type.GetTypeInfo().IsInterface || !type.IsByRefLike();
+        internal static bool IsConsumable(Type type) => !type.IsByRefLike();
 
         internal static bool HasConsumableField(Type type, out FieldInfo consumableField)
         {

src/BenchmarkDotNet/Helpers/Reflection.Emit/IlGeneratorDefaultValueExtensions.cs

@@ -19,6 +19,9 @@ public static void EmitSetLocalToDefault(this ILGenerator ilBuilder, LocalBuilde
             {
                 case Type t when t == typeof(void):
                     break;
+                case Type t when t.IsPointer: // Type.IsClass returns true for pointers, so we have to check for pointer type first.
+                    EmitInitObj(ilBuilder, resultType, local);
+                    break;
                 case Type t when t.IsClass || t.IsInterface:
                     ilBuilder.Emit(OpCodes.Ldnull);
                     ilBuilder.EmitStloc(local);

src/BenchmarkDotNet/Toolchains/InProcess/Emit/Implementation/Emitters/ConsumableConsumeEmitter.cs

@@ -80,8 +80,8 @@ protected override void OnEmitCtorBodyOverride(ConstructorBuilder constructorBui
 
         public override void EmitOverheadImplementation(ILGenerator ilBuilder, Type returnType)
         {
-            bool isByRefLike = returnType.IsByRefLike();
-            if (isByRefLike || (Consumer.IsConsumable(returnType) && !isByRefLike))
+            // ByRefLike types and pointers use default, everything else uses Unsafe.SkipInit.
+            if (returnType.IsByRefLike() || returnType.IsPointer)
             {
                 /*
                     // return default;