Introduce ConvertArgumentFromObjectExpression

... as the counterpart to `ConvertArgumentToObjectExpression`. For now,
this is just a simplified version of `ConvertExpression`, but it gives
us a place to add arguments-specific marshalling logic later on.

Author: stakx

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

@@ -0,0 +1,77 @@
+// Copyright 2004-2026 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.Generators.Emitters.SimpleAST
+{
+	using System;
+	using System.Diagnostics;
+	using System.Reflection.Emit;
+
+	internal class ConvertArgumentFromObjectExpression : IExpression
+	{
+		private readonly IExpression obj;
+		private Type dereferencedArgumentType;
+
+		public ConvertArgumentFromObjectExpression(Reference obj, Type dereferencedArgumentType)
+		{
+			Debug.Assert(obj.Type == typeof(object));
+			Debug.Assert(dereferencedArgumentType.IsByRef == false);
+
+			this.obj = obj;
+			this.dereferencedArgumentType = dereferencedArgumentType;
+		}
+
+		public void Emit(ILGenerator gen)
+		{
+			obj.Emit(gen);
+
+			if (dereferencedArgumentType == typeof(object))
+			{
+				return;
+			}
+
+			if (dereferencedArgumentType.IsValueType)
+			{
+				// Unbox conversion
+				// Assumes fromType is a boxed value
+				// if we can, we emit a box and ldind, otherwise, we will use unbox.any
+				if (LdindOpCodesDictionary.Instance[dereferencedArgumentType] != LdindOpCodesDictionary.EmptyOpCode)
+				{
+					gen.Emit(OpCodes.Unbox, dereferencedArgumentType);
+					OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, dereferencedArgumentType);
+				}
+				else
+				{
+					gen.Emit(OpCodes.Unbox_Any, dereferencedArgumentType);
+				}
+			}
+			else
+			{
+				// Possible down-cast
+				if (dereferencedArgumentType.IsGenericParameter)
+				{
+					gen.Emit(OpCodes.Unbox_Any, dereferencedArgumentType);
+				}
+				else if (dereferencedArgumentType.IsGenericType)
+				{
+					gen.Emit(OpCodes.Castclass, dereferencedArgumentType);
+				}
+				else if (dereferencedArgumentType.IsSubclassOf(typeof(object)))
+				{
+					gen.Emit(OpCodes.Castclass, dereferencedArgumentType);
+				}
+			}
+		}
+	}
+}

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

@@ -326,9 +326,9 @@ public void CopyOut(LocalReference argumentsArray)
 							method.CodeBuilder.AddStatement(
 								new AssignStatement(
 									dereferencedArgument,
-									new ConvertExpression(
-										dereferencedArgumentType,
-										new ArrayElementReference(argumentsArray, i))));
+									new ConvertArgumentFromObjectExpression(
+										new ArrayElementReference(argumentsArray, i),
+										dereferencedArgumentType)));
 						}
 					}
 				}
@@ -378,7 +378,7 @@ public void Return(LocalReference invocation)
 
 					method.CodeBuilder.AddStatement(
 						new ReturnStatement(
-							new ConvertExpression(returnType, returnValue)));
+							new ConvertArgumentFromObjectExpression(returnValue, returnType)));
 				}
 			}
 		}