Invoke converter for incoming argument values

Author: stakx

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

@@ -131,7 +131,11 @@ protected virtual ClassEmitter BuildClassEmitter(string typeName, Type parentTyp
 			CheckNotGenericTypeDefinition(parentType, nameof(parentType));
 			CheckNotGenericTypeDefinitions(interfaces, nameof(interfaces));
 
+#if FEATURE_BYREFLIKE
+			return new ClassEmitter(Scope, typeName, parentType, interfaces) { ByRefLikeConverterSelector = ProxyGenerationOptions.ByRefLikeConverterSelector };
+#else
 			return new ClassEmitter(Scope, typeName, parentType, interfaces);
+#endif
 		}
 
 		protected void CheckNotGenericTypeDefinition(Type type, string argumentName)

src/Castle.Core/DynamicProxy/Generators/Emitters/ClassEmitter.cs

@@ -65,6 +65,10 @@ public ClassEmitter(TypeBuilder typeBuilder)
 		{
 		}
 
+#if FEATURE_BYREFLIKE
+		public IByRefLikeConverterSelector ByRefLikeConverterSelector { get; set; }
+#endif
+
 		public ModuleScope ModuleScope
 		{
 			get { return moduleScope; }

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

@@ -18,14 +18,28 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	using System.Reflection;
 	using System.Reflection.Emit;
 
+	using Castle.DynamicProxy.Tokens;
+
 	internal class ReferencesToObjectArrayExpression : IExpression
 	{
 		private readonly TypeReference[] args;
 
+#if FEATURE_BYREFLIKE
+		private readonly MethodInfo proxiedMethod;
+		private readonly IByRefLikeConverterSelector byRefLikeConverterSelector;
+
+		public ReferencesToObjectArrayExpression(MethodInfo proxiedMethod, IByRefLikeConverterSelector byRefLikeConverterSelector, params TypeReference[] args)
+		{
+			this.proxiedMethod = proxiedMethod;
+			this.byRefLikeConverterSelector = byRefLikeConverterSelector;
+			this.args = args;
+		}
+#else
 		public ReferencesToObjectArrayExpression(params TypeReference[] args)
 		{
 			this.args = args;
 		}
+#endif
 
 		public void Emit(ILGenerator gen)
 		{
@@ -42,6 +56,37 @@ public void Emit(ILGenerator gen)
 
 				var reference = args[i];
 
+#if FEATURE_BYREFLIKE
+				if (reference.Type.IsByRefLike)
+				{
+					var converterType = byRefLikeConverterSelector?.SelectConverterType(proxiedMethod, i, reference.Type);
+					if (converterType != null)
+					{
+						// instantiate the by-ref-like value converter:
+						gen.Emit(OpCodes.Ldtoken, converterType);
+						gen.Emit(OpCodes.Call, TypeMethods.GetTypeFromHandle);
+						gen.EmitCall(OpCodes.Call, ActivatorMethods.CreateInstance, null);
+
+						// invoke it:
+						var boxMethodOnConverter = converterType.GetMethod("Box");
+						// (TODO: isn't there a nicer way to figure out whether or not the argument was passed by-ref,
+						// and then ensure that we end up with the argument's address on the evaluation stack?)
+						var argumentReference = (ArgumentReference)(reference is IndirectReference ? reference.OwnerReference : reference);
+						gen.Emit(argumentReference.Type.IsByRef ? OpCodes.Ldarg_S : OpCodes.Ldarga_S, argumentReference.Position);
+						gen.EmitCall(OpCodes.Callvirt, boxMethodOnConverter, null);
+					}
+					else
+					{
+						// no by-ref-like value converter is available, fall back to substituting the argument value with `null`
+						// because the logic further down would attempt to box it (which isn't allowed for by-ref-like values):
+						gen.Emit(OpCodes.Ldnull);
+					}
+
+					gen.Emit(OpCodes.Stelem_Ref);
+					continue;
+				}
+#endif
+
 				ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen);
 
 				if (reference.Type.IsByRef)

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

@@ -221,7 +221,11 @@ private IExpression[] GetCtorArguments(ClassEmitter @class, IExpression proxiedM
 				SelfReference.Self,
 				methodInterceptors ?? interceptors,
 				proxiedMethodTokenExpression,
+#if FEATURE_BYREFLIKE
+				new ReferencesToObjectArrayExpression(MethodToOverride, @class.ByRefLikeConverterSelector, dereferencedArguments)
+#else
 				new ReferencesToObjectArrayExpression(dereferencedArguments)
+#endif
 			};
 		}
 

src/Castle.Core/DynamicProxy/Tokens/ActivatorMethods.cs

@@ -0,0 +1,24 @@
+// Copyright 2004-2023 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.
+
+namespace Castle.DynamicProxy.Tokens
+{
+	using System;
+	using System.Reflection;
+
+	internal class ActivatorMethods
+	{
+		public static readonly MethodInfo CreateInstance = typeof(Activator).GetMethod("CreateInstance", new[] { typeof(Type) });
+	}
+}