Box by-ref-like arguments as System.Reflection.Pointer

Author: stakx

src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/DereferencePointerExpression.cs

@@ -0,0 +1,44 @@
+// Copyright 2004-2025 Castle Project - http://www.castleproject.org/
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if FEATURE_BYREFLIKE
+
+namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
+{
+	using System;
+	using System.Diagnostics;
+	using System.Reflection.Emit;
+
+	internal class DereferencePointerExpression : IExpression
+	{
+		private readonly IExpression pointerExpression;
+		private readonly Type pointerType;
+
+		public DereferencePointerExpression(IExpression pointerExpression, Type pointerType)
+		{
+			Debug.Assert(pointerType.IsPointer);
+
+			this.pointerExpression = pointerExpression;
+			this.pointerType = pointerType;
+		}
+
+		public void Emit(ILGenerator gen)
+		{
+			pointerExpression.Emit(gen);
+			gen.Emit(OpCodes.Ldobj, pointerType.GetElementType());
+		}
+	}
+}
+
+#endif

src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs

@@ -19,6 +19,7 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	using System.Reflection.Emit;
 
 	using Castle.DynamicProxy.Internal;
+	using Castle.DynamicProxy.Tokens;
 
 	internal class ReferencesToObjectArrayExpression : IExpression
 	{
@@ -47,11 +48,16 @@ public void Emit(ILGenerator gen)
 #if FEATURE_BYREFLIKE
 				if (reference.Type.IsByRefLikeSafe())
 				{
-					// The by-ref-like argument value cannot be put into the `object[]` array,
-					// because it cannot be boxed. We need to replace it with some other value.
-
-					// For now, we just erase it by substituting `null`:
-					gen.Emit(OpCodes.Ldnull);
+					// By-ref-like arguments cannot be put directly into the `object[]` array,
+					// because they cannot live on the heap. So instead we are taking their address,
+					// putting that in a `System.Reflection.Pointer`, and then store *that*:
+					var localCopy = gen.DeclareLocal(reference.Type);
+					ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);
+					gen.Emit(OpCodes.Stloc, localCopy);
+					gen.Emit(OpCodes.Ldloca, localCopy);
+					gen.Emit(OpCodes.Ldtoken, reference.Type.MakePointerType());
+					gen.Emit(OpCodes.Call, TypeMethods.GetTypeFromHandle);
+					gen.Emit(OpCodes.Call, PointerMethods.BoxMethod);
 					gen.Emit(OpCodes.Stelem_Ref);
 
 					continue;

src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs

@@ -16,6 +16,7 @@ namespace Castle.DynamicProxy.Generators
 {
 	using System;
 	using System.Collections.Generic;
+	using System.Linq.Expressions;
 	using System.Reflection;
 
 	using Castle.DynamicProxy.Contributors;
@@ -158,12 +159,14 @@ protected virtual void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocat
 #if FEATURE_BYREFLIKE
 					if (paramType.IsByRefLikeSafe())
 					{
-						// The argument value in the invocation `Arguments` array is an `object`
-						// and cannot be converted back to its original by-ref-like type.
-						// We need to replace it with some other value.
-
-						// For now, we just substitute the by-ref-like type's default value:
-						args[i] = new DefaultValueExpression(paramType);
+						// By-ref-like arguments are stored in the `Arguments` array
+						// as `System.Reflection.Pointer`s. Here we need to convert those back:
+						args[i] = new DereferencePointerExpression(
+							new MethodInvocationExpression(
+								null,
+								PointerMethods.UnboxMethod,
+								new MethodInvocationExpression(SelfReference.Self, InvocationMethods.GetArgumentValue, new LiteralIntExpression(i))),
+							paramType.MakePointerType());
 					}
 					else
 #endif