Merge pull request #710 from stakx/refactor/simple-ast-reference-subclasses

Remove `SimpleAST`'s false `Reference` subtypes, and add a missing one

Author: stakx

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

@@ -23,6 +23,4 @@ internal delegate MethodEmitter OverrideMethodDelegate(
 		string name, MethodAttributes attributes, MethodInfo methodToOverride);
 
 	internal delegate IExpression GetTargetExpressionDelegate(ClassEmitter @class, MethodInfo method);
-
-	internal delegate Reference GetTargetReferenceDelegate(ClassEmitter @class, MethodInfo method);
 }

src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithOptionalTargetContributor.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.
@@ -19,13 +19,9 @@ namespace Castle.DynamicProxy.Contributors
 
 	internal class InterfaceProxyWithOptionalTargetContributor : InterfaceProxyWithoutTargetContributor
 	{
-		private readonly GetTargetReferenceDelegate getTargetReference;
-
-		public InterfaceProxyWithOptionalTargetContributor(INamingScope namingScope, GetTargetExpressionDelegate getTarget,
-		                                                   GetTargetReferenceDelegate getTargetReference)
+		public InterfaceProxyWithOptionalTargetContributor(INamingScope namingScope, GetTargetExpressionDelegate getTarget)
 			: base(namingScope, getTarget)
 		{
-			this.getTargetReference = getTargetReference;
 			canChangeTarget = true;
 		}
 
@@ -34,7 +30,7 @@ protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEm
 		{
 			if (!method.Proxyable)
 			{
-				return new OptionallyForwardingMethodGenerator(method, overrideMethod, getTargetReference);
+				return new OptionallyForwardingMethodGenerator(method, overrideMethod, getTarget);
 			}
 
 			return base.GetMethodGenerator(method, @class, overrideMethod);

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

@@ -26,13 +26,13 @@ namespace Castle.DynamicProxy.Contributors
 
 	internal class InterfaceProxyWithoutTargetContributor : CompositeTypeContributor
 	{
-		private readonly GetTargetExpressionDelegate getTargetExpression;
+		protected readonly GetTargetExpressionDelegate getTarget;
 		protected bool canChangeTarget = false;
 
 		public InterfaceProxyWithoutTargetContributor(INamingScope namingScope, GetTargetExpressionDelegate getTarget)
 			: base(namingScope)
 		{
-			getTargetExpression = getTarget;
+			this.getTarget = getTarget;
 		}
 
 		protected override IEnumerable<MembersCollector> GetCollectors()
@@ -56,7 +56,7 @@ protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEm
 			return new MethodWithInvocationGenerator(method,
 			                                         @class.GetField("__interceptors"),
 			                                         invocation,
-			                                         getTargetExpression,
+			                                         getTarget,
 			                                         overrideMethod,
 			                                         null);
 		}

src/Castle.Core/DynamicProxy/Contributors/MixinContributor.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.
@@ -114,7 +114,7 @@ private GetTargetExpressionDelegate BuildGetTargetExpression()
 			}
 
 			return (c, m) => new NullCoalescingOperatorExpression(
-			                 	new AsTypeReference(c.GetField("__target"), m.DeclaringType),
+			                 	new AsTypeExpression(c.GetField("__target"), m.DeclaringType),
 			                 	fields[m.DeclaringType]);
 		}
 

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
 

…mpleAST/LoadRefArrayElementExpression.cs …mitters/SimpleAST/AddressOfExpression.cssrc/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LoadRefArrayElementExpression.cs renamed to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AddressOfExpression.cs src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LoadRefArrayElementExpression.cs renamed to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AddressOfExpression.cs

@@ -16,24 +16,22 @@
 
 namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 {
+	using System.Diagnostics;
 	using System.Reflection.Emit;
 
-	internal class LoadRefArrayElementExpression : IExpression
+	[DebuggerDisplay("&{reference}")]
+	internal class AddressOfExpression : IExpression
 	{
-		private readonly Reference arrayReference;
-		private readonly LiteralIntExpression index;
+		private readonly Reference reference;
 
-		public LoadRefArrayElementExpression(int index, Reference arrayReference)
+		public AddressOfExpression(Reference reference)
 		{
-			this.index = new LiteralIntExpression(index);
-			this.arrayReference = arrayReference;
+			this.reference = reference;
 		}
 
 		public void Emit(ILGenerator gen)
 		{
-			arrayReference.Emit(gen);
-			index.Emit(gen);
-			gen.Emit(OpCodes.Ldelem_Ref);
+			reference.EmitAddress(gen);
 		}
 	}
 }

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);
+		}
+	}
+}

…rs/Emitters/SimpleAST/AsTypeReference.cs …s/Emitters/SimpleAST/AsTypeExpression.cssrc/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeReference.cs renamed to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeExpression.cs src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeReference.cs renamed to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeExpression.cs

@@ -21,36 +21,21 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	using System.Reflection.Emit;
 
 	[DebuggerDisplay("{reference} as {type}")]
-	internal class AsTypeReference : Reference
+	internal class AsTypeExpression : IExpression
 	{
 		private readonly Reference reference;
 		private readonly Type type;
 
-		public AsTypeReference(Reference reference, Type type)
-			: base(type)
+		public AsTypeExpression(Reference reference, Type type)
 		{
 			this.reference = reference;
 			this.type = type;
 		}
 
-		public override void EmitAddress(ILGenerator gen)
-		{
-			// It does not make sense to take the address of a cast expression.
-			// The C# language would also forbid address-taking of the form `&(x as T)`.
-			throw new NotSupportedException();
-		}
-
-		public override void Emit(ILGenerator gen)
+		public void Emit(ILGenerator gen)
 		{
 			reference.Emit(gen);
 			gen.Emit(OpCodes.Isinst, type);
 		}
-
-		public override void EmitStore(IExpression value, ILGenerator gen)
-		{
-			// It does not make sense to assign a value to the result of a cast expression.
-			// The C# language would also forbid assignments of the form `(x as T) = y`.
-			throw new NotSupportedException();
-		}
 	}
 }