Add missing ArrayElementReference

Author: stakx

src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs

@@ -1,4 +1,4 @@
-// Copyright 2004-2021 Castle Project - http://www.castleproject.org/
+// 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.
@@ -90,9 +90,8 @@ protected void ImplementGetObjectData(ClassEmitter emitter)
 			for (var i = 0; i < interfaces.Length; i++)
 			{
 				getObjectData.CodeBuilder.AddStatement(
-					new AssignArrayStatement(
-						interfacesLocal,
-						i,
+					new AssignStatement(
+						new ArrayElementReference(interfacesLocal, i),
 						new LiteralStringExpression(interfaces[i].AssemblyQualifiedName)));
 			}
 

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

@@ -1,4 +1,4 @@
-// Copyright 2004-2021 Castle Project - http://www.castleproject.org/
+// 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.
@@ -331,7 +331,9 @@ protected void GenerateParameterlessConstructor(ClassEmitter emitter, Type baseC
 			constructor.CodeBuilder.AddStatement(new AssignStatement(interceptorField,
 			                                                         new NewArrayExpression(1, typeof(IInterceptor))));
 			constructor.CodeBuilder.AddStatement(
-				new AssignArrayStatement(interceptorField, 0, new NewInstanceExpression(typeof(StandardInterceptor))));
+				new AssignStatement(
+					new ArrayElementReference(interceptorField, 0),
+					new NewInstanceExpression(typeof(StandardInterceptor))));
 
 			// Invoke base constructor
 

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

@@ -0,0 +1,64 @@
+// 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.
+
+#nullable enable
+
+namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
+{
+	using System.Diagnostics;
+	using System.Reflection.Emit;
+
+	internal sealed class ArrayElementReference : Reference
+	{
+		private readonly Reference array;
+		private readonly int index;
+
+		public ArrayElementReference(Reference array, int index)
+			: base(array.Type.GetElementType()!)
+		{
+			Debug.Assert(array.Type.IsArray);
+
+			// The below methods have the `ldelem.ref` and `stelem.ref` opcodes hardcoded,
+			// which is only correct for reference types. Once we start using this class
+			// for arrays of primitive types, enums, value types, or generic parameters,
+			// we will need to revisit this.
+			Debug.Assert(array.Type.GetElementType()!.IsClass || array.Type.GetElementType()!.IsInterface);
+
+			this.array = array;
+			this.index = index;
+		}
+
+		public override void Emit(ILGenerator gen)
+		{
+			array.Emit(gen);
+			gen.Emit(OpCodes.Ldc_I4, index);
+			gen.Emit(OpCodes.Ldelem_Ref);
+		}
+
+		public override void EmitAddress(ILGenerator gen)
+		{
+			array.Emit(gen);
+			gen.Emit(OpCodes.Ldc_I4, index);
+			gen.Emit(OpCodes.Ldelema);
+		}
+
+		public override void EmitStore(IExpression value, ILGenerator gen)
+		{
+			array.Emit(gen);
+			gen.Emit(OpCodes.Ldc_I4, index);
+			value.Emit(gen);
+			gen.Emit(OpCodes.Stelem_Ref);
+		}
+	}
+}

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

@@ -133,7 +133,7 @@ bool IsReadOnly(ParameterInfo parameter)
 
 		private static ConvertExpression Argument(int i, LocalReference invocationArgs, Reference[] arguments)
 		{
-			return new ConvertExpression(arguments[i].Type, new LoadRefArrayElementExpression(i, invocationArgs));
+			return new ConvertExpression(arguments[i].Type, new ArrayElementReference(invocationArgs, i));
 		}
 
 		private static AssignStatement AssignArgument(Reference[] dereferencedArguments, int i,

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

@@ -222,7 +222,9 @@ private void EmitLoadGenericMethodArguments(MethodEmitter methodEmitter, MethodI
 			for (var i = 0; i < genericParameters.Length; ++i)
 			{
 				methodEmitter.CodeBuilder.AddStatement(
-					new AssignArrayStatement(genericParamsArrayLocal, i, new TypeTokenExpression(genericParameters[i])));
+					new AssignStatement(
+						new ArrayElementReference(genericParamsArrayLocal, i),
+						new TypeTokenExpression(genericParameters[i])));
 			}
 			methodEmitter.CodeBuilder.AddStatement(
 				new MethodInvocationExpression(invocationLocal,