Support ByRef arguments in event handlers

tminka · tminka · commit 1f3fec7a6f58 · 2021-01-21T20:35:26.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -47,8 +47,9 @@ when .NET expects an integer [#1342][i1342]
 -    Fixed issue when calling PythonException.Format where another exception would be raise for unnormalized exceptions
 -    Made it possible to call `ToString`, `GetHashCode`, and `GetType` on inteface objects
 -    Fixed objects returned by enumerating `PyObject` being disposed too soon
--    Incorrectly using a non-generic type with type parameters now produces a helpful Python error instead of throwing NullReferenceException
--   `import` may now raise errors with more detail than "No module named X"
+-    Incorrectly using a non-generic type with type parameters now produces a helpful Python error instead of throwing NullReferenceException ([#1325][i1325])
+-    `import` may now raise errors with more detail than "No module named X"
+-    Fixed a crash when invoking a Python event handler for an event with a ByRef argument ([#1355][i1355])
 
 ### Removed
 
diff --git a/src/runtime/delegatemanager.cs b/src/runtime/delegatemanager.cs
@@ -118,6 +118,20 @@ private Type GetDispatcher(Type dtype)
                 il.Emit(OpCodes.Ldloc_0);
                 il.Emit(OpCodes.Ldarg_S, (byte)(c + 1));
 
+                if (t.IsByRef)
+                {
+                    // The argument is a pointer.  We must dereference the pointer to get the value or object it points to.
+                    t = t.GetElementType();
+                    if (t.IsValueType)
+                    {
+                        il.Emit(OpCodes.Ldobj, t);
+                    }
+                    else
+                    {
+                        il.Emit(OpCodes.Ldind_Ref);
+                    }
+                }
+
                 if (t.IsValueType)
                 {
                     il.Emit(OpCodes.Box, t);
diff --git a/src/testing/eventtest.cs b/src/testing/eventtest.cs
@@ -7,8 +7,10 @@ namespace Python.Test
     /// </summary>
     public delegate void EventHandlerTest(object sender, EventArgsTest e);
 
+    public delegate void EventWithRefStringArgument(ref string data);
+    public delegate void EventWithRefIntArgument(ref int data);
 
-    #pragma warning disable 67 // Unused events, these are only accessed from Python
+#pragma warning disable 67 // Unused events, these are only accessed from Python
     public class EventTest
     {
         public static event EventHandlerTest PublicStaticEvent;
@@ -27,6 +29,8 @@ public class EventTest
 
         private event EventHandlerTest PrivateEvent;
 
+        public event EventWithRefStringArgument RefStringEvent;
+        public event EventWithRefIntArgument RefIntEvent;
 
         public static int s_value;
         public int value;
@@ -77,6 +81,15 @@ protected static void OnProtectedStaticEvent(EventArgsTest e)
             }
         }
 
+        public void OnRefStringEvent(string data)
+        {
+            RefStringEvent?.Invoke(ref data);
+        }
+
+        public void OnRefIntEvent(int data)
+        {
+            RefIntEvent?.Invoke(ref data);
+        }
 
         public void GenericHandler(object sender, EventArgsTest e)
         {
@@ -88,6 +101,16 @@ public static void StaticHandler(object sender, EventArgsTest e)
             s_value = e.value;
         }
 
+        public void RefStringHandler(ref string data)
+        {
+            value = data.Length;
+        }
+
+        public void RefIntHandler(ref int data)
+        {
+            value = data;
+        }
+
         public static void ShutUpCompiler()
         {
             // Quiet compiler warnings.
diff --git a/src/tests/test_event.py b/src/tests/test_event.py
@@ -295,6 +295,25 @@ def handler(sender, args, dict_=dict_):
     ob.OnPublicEvent(EventArgsTest(20))
     assert dict_['value'] == 10
 
+def test_byref_function_handler():
+    """Test function handlers with ByRef arguments."""
+    ob = EventTest()
+
+    value = 10
+    def handler(data):
+        assert data == value
+        ob.value = ob.value + 1
+
+    ob.RefIntEvent += ob.RefIntHandler
+    ob.RefIntEvent += handler
+    ob.OnRefIntEvent(value)
+    assert ob.value == value + 1
+
+    ob.RefStringEvent += ob.RefStringHandler
+    ob.RefStringEvent += handler
+    value = 'This is the event data'
+    ob.OnRefStringEvent(value)
+    assert ob.value == len(value) + 1
 
 def test_add_non_callable_handler():
     """Test handling of attempts to add non-callable handlers."""
