Fix: using default value for nullable enum parameter throws ArgumentException (#71388)

Author: buyaa-n

src/coreclr/nativeaot/System.Private.CoreLib/src/System/InvokeUtils.cs

@@ -569,18 +569,28 @@ public static object DynamicInvokeParamHelperCore(ref ArgSetupState argSetupStat
 
             Debug.Assert(argSetupState.parameters != null);
             object? incomingParam = argSetupState.parameters[index];
+            bool nullable = type.ToEETypePtr().IsNullable;
 
             // Handle default parameters
             if ((incomingParam == System.Reflection.Missing.Value) && paramType == DynamicInvokeParamType.In)
             {
                 incomingParam = GetDefaultValue(argSetupState.targetMethodOrDelegate, type, index);
+                if (incomingParam != null && nullable)
+                {
+                    // In case if the parameter is nullable Enum type the ParameterInfo.DefaultValue returns a raw value which
+                    // needs to be parsed to the Enum type, for more info: https://github.com/dotnet/runtime/issues/12924
+                    EETypePtr nullableType = type.ToEETypePtr().NullableType;
+                    if (nullableType.IsEnum)
+                    {
+                        incomingParam = Enum.ToObject(Type.GetTypeFromEETypePtr(nullableType), incomingParam);
+                    }
+                }
 
                 // The default value is captured into the parameters array
                 argSetupState.parameters[index] = incomingParam;
             }
 
             RuntimeTypeHandle widenAndCompareType = type;
-            bool nullable = type.ToEETypePtr().IsNullable;
             if (nullable)
             {
                 widenAndCompareType = new RuntimeTypeHandle(type.ToEETypePtr().NullableType);

src/libraries/System.Private.CoreLib/src/System/Reflection/MethodBase.cs

@@ -207,6 +207,17 @@ BindingFlags invokeAttr
                         }
                         else
                         {
+                            if (arg != null && sigType.IsNullableOfT)
+                            {
+                                // In case if the parameter is nullable Enum type the ParameterInfo.DefaultValue returns a raw value which
+                                // needs to be parsed to the Enum type, for more info: https://github.com/dotnet/runtime/issues/12924
+                                Type argumentType = sigType.GetGenericArguments()[0];
+                                if (argumentType.IsEnum)
+                                {
+                                    arg = Enum.ToObject(argumentType, arg);
+                                }
+                            }
+
                             isValueType = sigType.CheckValue(ref arg, ref copyBackArg, binder, culture, invokeAttr);
                         }
                     }

src/libraries/System.Reflection/tests/MethodInfoTests.cs

@@ -708,6 +708,61 @@ static MethodInfo GetMethod(string name) => typeof(EnumMethods).GetMethod(
                 name, BindingFlags.Public | BindingFlags.Static)!;
         }
 
+        [Fact]
+        public static void InvokeNullableEnumParameterDefaultNo()
+        {
+            MethodInfo method = typeof(EnumMethods).GetMethod("NullableEnumDefaultNo", BindingFlags.Static | BindingFlags.NonPublic);
+
+            Assert.Null(method.Invoke(null, new object?[] { default(object) }));
+            Assert.Equal(YesNo.No, method.Invoke(null, new object?[] { YesNo.No }));
+            Assert.Equal(YesNo.Yes, method.Invoke(null, new object?[] { YesNo.Yes }));
+            Assert.Equal(YesNo.No, method.Invoke(null, new object?[] { Type.Missing }));
+        } 
+
+        [Fact]
+        public static void InvokeNullableEnumParameterDefaultYes()
+        {
+            MethodInfo method = typeof(EnumMethods).GetMethod("NullableEnumDefaultYes", BindingFlags.Static | BindingFlags.NonPublic);
+
+            Assert.Null(method.Invoke(null, new object?[] { default(object) }));
+            Assert.Equal(YesNo.No, method.Invoke(null, new object?[] { YesNo.No }));
+            Assert.Equal(YesNo.Yes, method.Invoke(null, new object?[] { YesNo.Yes }));
+            Assert.Equal(YesNo.Yes, method.Invoke(null, new object?[] { Type.Missing }));
+        }
+
+        [Fact]
+        public static void InvokeNonNullableEnumParameterDefaultYes()
+        {
+            MethodInfo method = typeof(EnumMethods).GetMethod("NonNullableEnumDefaultYes", BindingFlags.Static | BindingFlags.NonPublic);
+
+            Assert.Equal(YesNo.No, method.Invoke(null, new object[] { default(object) }));
+            Assert.Equal(YesNo.No, method.Invoke(null, new object[] { YesNo.No }));
+            Assert.Equal(YesNo.Yes, method.Invoke(null, new object[] { YesNo.Yes }));
+            Assert.Equal(YesNo.Yes, method.Invoke(null, new object[] { Type.Missing }));
+        }
+
+        [Fact]
+        public static void InvokeNullableEnumParameterDefaultNull()
+        {
+            MethodInfo method = typeof(EnumMethods).GetMethod("NullableEnumDefaultNull", BindingFlags.Static | BindingFlags.NonPublic);
+
+            Assert.Null(method.Invoke(null, new object?[] { default(object) }));
+            Assert.Equal(YesNo.No, method.Invoke(null, new object?[] { YesNo.No }));
+            Assert.Equal(YesNo.Yes, method.Invoke(null, new object?[] { YesNo.Yes }));
+            Assert.Null(method.Invoke(null, new object?[] { Type.Missing }));
+        }
+
+        [Fact]
+        public static void InvokeNullableEnumParameterNoDefault()
+        {
+            MethodInfo method = typeof(EnumMethods).GetMethod("NullableEnumNoDefault", BindingFlags.Static | BindingFlags.NonPublic);
+
+            Assert.Null(method.Invoke(null, new object?[] { default(object) }));
+            Assert.Equal(YesNo.No, method.Invoke(null, new object?[] { YesNo.No }));
+            Assert.Equal(YesNo.Yes, method.Invoke(null, new object?[] { YesNo.Yes }));
+            Assert.Throws<ArgumentException>(() => method.Invoke(null, new object?[] { Type.Missing }));
+        }
+
         [Fact]
         public void ValueTypeMembers_WithOverrides()
         {
@@ -1140,6 +1195,12 @@ public struct ValueTypeWithoutOverrides
         public int GetId() => Id;
     }
 
+    public enum YesNo
+    {
+        No = 0,
+        Yes = 1,
+    }
+
     public static class EnumMethods
     {
         public static bool PassColorsInt(ColorsInt color)
@@ -1153,6 +1214,31 @@ public static bool PassColorsShort(ColorsShort color)
             Assert.Equal(ColorsShort.Red, color);
             return true;
         }
+
+        static YesNo NonNullableEnumDefaultYes(YesNo yesNo = YesNo.Yes)
+        {
+            return yesNo;
+        }
+
+        static YesNo? NullableEnumDefaultNo(YesNo? yesNo = YesNo.No)
+        {
+            return yesNo;
+        }
+
+        static YesNo? NullableEnumDefaultYes(YesNo? yesNo = YesNo.Yes)
+        {
+            return yesNo;
+        }
+
+        static YesNo? NullableEnumDefaultNull(YesNo? yesNo = null)
+        {
+            return yesNo;
+        }
+
+        static YesNo? NullableEnumNoDefault(YesNo? yesNo)
+        {
+            return yesNo;
+        }
     }
 #pragma warning restore 0414
 }