Merge pull request #711 from stakx/refactor/simple-ast

stakx · web-flow · commit efff684ced13 · 2025-12-18T01:04:32.000+01:00
Various minor `SimpleAST` refactorings
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/CodeBuilder.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/CodeBuilder.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.
@@ -22,14 +22,12 @@ namespace Castle.DynamicProxy.Generators.Emitters
 
 	internal sealed class CodeBuilder
 	{
-		private readonly List<LocalReference> locals;
 		private readonly List<IStatement> statements;
 		private bool isEmpty;
 
 		public CodeBuilder()
 		{
 			statements = new List<IStatement>();
-			locals = new List<LocalReference>();
 			isEmpty = true;
 		}
 
@@ -47,18 +45,11 @@ public CodeBuilder AddStatement(IStatement statement)
 
 		public LocalReference DeclareLocal(Type type)
 		{
-			var local = new LocalReference(type);
-			locals.Add(local);
-			return local;
+			return new LocalReference(type);
 		}
 
 		internal void Generate(ILGenerator il)
 		{
-			foreach (var local in locals)
-			{
-				local.Generate(il);
-			}
-
 			foreach (var statement in statements)
 			{
 				statement.Emit(il);
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeExpression.cs
@@ -20,21 +20,21 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	using System.Diagnostics;
 	using System.Reflection.Emit;
 
-	[DebuggerDisplay("{reference} as {type}")]
+	[DebuggerDisplay("{expression} as {type}")]
 	internal class AsTypeExpression : IExpression
 	{
-		private readonly Reference reference;
+		private readonly IExpression expression;
 		private readonly Type type;
 
-		public AsTypeExpression(Reference reference, Type type)
+		public AsTypeExpression(IExpression expression, Type type)
 		{
-			this.reference = reference;
+			this.expression = expression;
 			this.type = type;
 		}
 
 		public void Emit(ILGenerator gen)
 		{
-			reference.Emit(gen);
+			expression.Emit(gen);
 			gen.Emit(OpCodes.Isinst, type);
 		}
 	}
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArgumentStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArgumentStatement.cs
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/DefaultValueExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/DefaultValueExpression.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.
@@ -42,34 +42,12 @@ public void Emit(ILGenerator gen)
 				gen.Emit(OpCodes.Initobj, type);
 				gen.Emit(OpCodes.Ldloc, local);
 			}
-			else if (type.IsByRef)
-			{
-				EmitByRef(gen);
-			}
 			else
 			{
 				throw new NotImplementedException("Can't emit default value for type " + type);
 			}
 		}
 
-		private void EmitByRef(ILGenerator gen)
-		{
-			var elementType = type.GetElementType();
-			if (IsPrimitiveOrClass(elementType))
-			{
-				OpCodeUtil.EmitLoadOpCodeForDefaultValueOfType(gen, elementType);
-				OpCodeUtil.EmitStoreIndirectOpCodeForType(gen, elementType);
-			}
-			else if (elementType.IsGenericParameter || elementType.IsValueType)
-			{
-				gen.Emit(OpCodes.Initobj, elementType);
-			}
-			else
-			{
-				throw new NotImplementedException("Can't emit default value for reference of type " + elementType);
-			}
-		}
-
 		private bool IsPrimitiveOrClass(Type type)
 		{
 			if (type.IsPrimitive && type != typeof(IntPtr) && type != typeof(UIntPtr))
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs
@@ -20,7 +20,7 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	using System.Reflection;
 	using System.Reflection.Emit;
 
-	[DebuggerDisplay("{fieldBuilder.Name} ({fieldBuilder.FieldType})")]
+	[DebuggerDisplay("{field.Name} ({field.FieldType})")]
 	internal class FieldReference : Reference
 	{
 		private readonly FieldInfo field;
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IfNullExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IfNullExpression.cs
@@ -23,15 +23,7 @@ internal class IfNullExpression : IExpression, IStatement
 	{
 		private readonly IExpressionOrStatement ifNotNull;
 		private readonly IExpressionOrStatement ifNull;
-		private readonly Reference? reference;
-		private readonly IExpression? expression;
-
-		public IfNullExpression(Reference reference, IExpressionOrStatement ifNull, IExpressionOrStatement ifNotNull = null)
-		{
-			this.reference = reference ?? throw new ArgumentNullException(nameof(reference));
-			this.ifNull = ifNull;
-			this.ifNotNull = ifNotNull;
-		}
+		private readonly IExpression expression;
 
 		public IfNullExpression(IExpression expression, IExpressionOrStatement ifNull, IExpressionOrStatement ifNotNull = null)
 		{
@@ -42,15 +34,7 @@ public IfNullExpression(IExpression expression, IExpressionOrStatement ifNull, I
 
 		public void Emit(ILGenerator gen)
 		{
-			if (reference != null)
-			{
-				reference.Emit(gen);
-			}
-			else if (expression != null)
-			{
-				expression.Emit(gen);
-			}
-
+			expression.Emit(gen);
 			var notNull = gen.DefineLabel();
 			gen.Emit(OpCodes.Brtrue_S, notNull);
 			ifNull.Emit(gen);
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs
@@ -22,10 +22,11 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	using System.Reflection.Emit;
 
 	/// <summary>
-	///   Wraps a reference that is passed 
-	///   ByRef and provides indirect load/store support.
+	///   Represents the storage location <c>X</c> referenced by a <see cref="Reference"/>
+	///   holding a managed pointer ("by-ref") <c>&amp;X</c> to it.
+	///   It essentially has the same function as the pointer indirection / dereferencing operator <c>*</c>.
 	/// </summary>
-	[DebuggerDisplay("&{OwnerReference}")]
+	[DebuggerDisplay("*{byRefReference}")]
 	internal class IndirectReference : Reference
 	{
 		private readonly Reference byRefReference;
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs
@@ -23,32 +23,32 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	[DebuggerDisplay("local {Type}")]
 	internal class LocalReference : Reference
 	{
-		private LocalBuilder? localBuilder;
+		private LocalBuilder? local;
 
 		public LocalReference(Type type)
 			: base(type)
 		{
 		}
 
-		public override void Generate(ILGenerator gen)
-		{
-			localBuilder = gen.DeclareLocal(base.Type);
-		}
-
 		public override void EmitAddress(ILGenerator gen)
 		{
-			gen.Emit(OpCodes.Ldloca, localBuilder!);
+			gen.Emit(OpCodes.Ldloca, GetInitializedLocal(gen));
 		}
 
 		public override void Emit(ILGenerator gen)
 		{
-			gen.Emit(OpCodes.Ldloc, localBuilder!);
+			gen.Emit(OpCodes.Ldloc, GetInitializedLocal(gen));
 		}
 
 		public override void EmitStore(IExpression value, ILGenerator gen)
 		{
 			value.Emit(gen);
-			gen.Emit(OpCodes.Stloc, localBuilder!);
+			gen.Emit(OpCodes.Stloc, GetInitializedLocal(gen));
+		}
+
+		private LocalBuilder GetInitializedLocal(ILGenerator gen)
+		{
+			return local ??= gen.DeclareLocal(Type);
 		}
 	}
 }
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/NewArrayExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/NewArrayExpression.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,19 +19,19 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 
 	internal class NewArrayExpression : IExpression
 	{
-		private readonly Type arrayType;
+		private readonly Type elementType;
 		private readonly int size;
 
-		public NewArrayExpression(int size, Type arrayType)
+		public NewArrayExpression(int size, Type elementType)
 		{
 			this.size = size;
-			this.arrayType = arrayType;
+			this.elementType = elementType;
 		}
 
 		public void Emit(ILGenerator gen)
 		{
 			gen.Emit(OpCodes.Ldc_I4, size);
-			gen.Emit(OpCodes.Newarr, arrayType);
+			gen.Emit(OpCodes.Newarr, elementType);
 		}
 	}
 }
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs
@@ -38,9 +38,5 @@ public Type Type
 		public abstract void Emit(ILGenerator gen);
 
 		public abstract void EmitStore(IExpression value, ILGenerator gen);
-
-		public virtual void Generate(ILGenerator gen)
-		{
-		}
 	}
 }
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReturnStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReturnStatement.cs
@@ -21,33 +21,19 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	internal class ReturnStatement : IStatement
 	{
 		private readonly IExpression? expression;
-		private readonly Reference? reference;
 
 		public ReturnStatement()
 		{
 		}
 
-		public ReturnStatement(Reference reference)
-		{
-			this.reference = reference;
-		}
-
 		public ReturnStatement(IExpression expression)
 		{
 			this.expression = expression;
 		}
 
 		public void Emit(ILGenerator gen)
 		{
-			if (reference != null)
-			{
-				reference.Emit(gen);
-			}
-			else if (expression != null)
-			{
-				expression.Emit(gen);
-			}
-
+			expression?.Emit(gen);
 			gen.Emit(OpCodes.Ret);
 		}
 	}
diff --git a/src/Castle.Core/DynamicProxy/Generators/MinimalisticMethodGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/MinimalisticMethodGenerator.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.
@@ -52,8 +52,10 @@ private void InitOutParameters(MethodEmitter emitter, ParameterInfo[] parameters
 				if (parameter.IsOut)
 				{
 					emitter.CodeBuilder.AddStatement(
-						new AssignArgumentStatement(new ArgumentReference(parameter.ParameterType, index + 1),
-						                            new DefaultValueExpression(parameter.ParameterType)));
+						new AssignStatement(
+							new IndirectReference(
+								new ArgumentReference(parameter.ParameterType, index + 1)),
+							new DefaultValueExpression(parameter.ParameterType.GetElementType())));
 				}
 			}
 		}
diff --git a/src/Castle.Core/DynamicProxy/Generators/OptionallyForwardingMethodGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/OptionallyForwardingMethodGenerator.cs
@@ -84,8 +84,10 @@ private void InitOutParameters(BlockStatement statements, ParameterInfo[] parame
 				if (parameter.IsOut)
 				{
 					statements.AddStatement(
-						new AssignArgumentStatement(new ArgumentReference(parameter.ParameterType, index + 1),
-						                            new DefaultValueExpression(parameter.ParameterType)));
+						new AssignStatement(
+							new IndirectReference(
+								new ArgumentReference(parameter.ParameterType, index + 1)),
+							new DefaultValueExpression(parameter.ParameterType.GetElementType())));
 				}
 			}
 		}

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// Copyright 2004-2021 Castle Project - http://www.castleproject.org/`
	`1`	`+// Copyright 2004-2025 Castle Project - http://www.castleproject.org/`
`2`	`2`	`//`
`3`	`3`	`// Licensed under the Apache License, Version 2.0 (the "License");`
`4`	`4`	`// you may not use this file except in compliance with the License.`
`@@ -22,14 +22,12 @@ namespace Castle.DynamicProxy.Generators.Emitters`
`22`	`22`
`23`	`23`	`internal sealed class CodeBuilder`
`24`	`24`	`{`
`25`		`- private readonly List<LocalReference> locals;`
`26`	`25`	`private readonly List<IStatement> statements;`
`27`	`26`	`private bool isEmpty;`
`28`	`27`
`29`	`28`	`public CodeBuilder()`
`30`	`29`	`{`
`31`	`30`	`statements = new List<IStatement>();`
`32`		`- locals = new List<LocalReference>();`
`33`	`31`	`isEmpty = true;`
`34`	`32`	`}`
`35`	`33`
`@@ -47,18 +45,11 @@ public CodeBuilder AddStatement(IStatement statement)`
`47`	`45`
`48`	`46`	`public LocalReference DeclareLocal(Type type)`
`49`	`47`	`{`
`50`		`- var local = new LocalReference(type);`
`51`		`- locals.Add(local);`
`52`		`- return local;`
	`48`	`+ return new LocalReference(type);`
`53`	`49`	`}`
`54`	`50`
`55`	`51`	`internal void Generate(ILGenerator il)`
`56`	`52`	`{`
`57`		`- foreach (var local in locals)`
`58`		`- {`
`59`		`- local.Generate(il);`
`60`		`- }`
`61`		`-`
`62`	`53`	`foreach (var statement in statements)`
`63`	`54`	`{`
`64`	`55`	`statement.Emit(il);`
Original file line number	Diff line number	Diff line change
`@@ -20,21 +20,21 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST`
`20`	`20`	`using System.Diagnostics;`
`21`	`21`	`using System.Reflection.Emit;`
`22`	`22`
`23`		`- [DebuggerDisplay("{reference} as {type}")]`
	`23`	`+ [DebuggerDisplay("{expression} as {type}")]`
`24`	`24`	`internal class AsTypeExpression : IExpression`
`25`	`25`	`{`
`26`		`- private readonly Reference reference;`
	`26`	`+ private readonly IExpression expression;`
`27`	`27`	`private readonly Type type;`
`28`	`28`
`29`		`- public AsTypeExpression(Reference reference, Type type)`
	`29`	`+ public AsTypeExpression(IExpression expression, Type type)`
`30`	`30`	`{`
`31`		`- this.reference = reference;`
	`31`	`+ this.expression = expression;`
`32`	`32`	`this.type = type;`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`public void Emit(ILGenerator gen)`
`36`	`36`	`{`
`37`		`- reference.Emit(gen);`
	`37`	`+ expression.Emit(gen);`
`38`	`38`	`gen.Emit(OpCodes.Isinst, type);`
`39`	`39`	`}`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST`
`20`	`20`	`using System.Reflection;`
`21`	`21`	`using System.Reflection.Emit;`
`22`	`22`
`23`		`- [DebuggerDisplay("{fieldBuilder.Name} ({fieldBuilder.FieldType})")]`
	`23`	`+ [DebuggerDisplay("{field.Name} ({field.FieldType})")]`
`24`	`24`	`internal class FieldReference : Reference`
`25`	`25`	`{`
`26`	`26`	`private readonly FieldInfo field;`
Original file line number	Diff line number	Diff line change
`@@ -23,32 +23,32 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST`
`23`	`23`	`[DebuggerDisplay("local {Type}")]`
`24`	`24`	`internal class LocalReference : Reference`
`25`	`25`	`{`
`26`		`- private LocalBuilder? localBuilder;`
	`26`	`+ private LocalBuilder? local;`
`27`	`27`
`28`	`28`	`public LocalReference(Type type)`
`29`	`29`	`: base(type)`
`30`	`30`	`{`
`31`	`31`	`}`
`32`	`32`
`33`		`- public override void Generate(ILGenerator gen)`
`34`		`- {`
`35`		`- localBuilder = gen.DeclareLocal(base.Type);`
`36`		`- }`
`37`		`-`
`38`	`33`	`public override void EmitAddress(ILGenerator gen)`
`39`	`34`	`{`
`40`		`- gen.Emit(OpCodes.Ldloca, localBuilder!);`
	`35`	`+ gen.Emit(OpCodes.Ldloca, GetInitializedLocal(gen));`
`41`	`36`	`}`
`42`	`37`
`43`	`38`	`public override void Emit(ILGenerator gen)`
`44`	`39`	`{`
`45`		`- gen.Emit(OpCodes.Ldloc, localBuilder!);`
	`40`	`+ gen.Emit(OpCodes.Ldloc, GetInitializedLocal(gen));`
`46`	`41`	`}`
`47`	`42`
`48`	`43`	`public override void EmitStore(IExpression value, ILGenerator gen)`
`49`	`44`	`{`
`50`	`45`	`value.Emit(gen);`
`51`		`- gen.Emit(OpCodes.Stloc, localBuilder!);`
	`46`	`+ gen.Emit(OpCodes.Stloc, GetInitializedLocal(gen));`
	`47`	`+ }`
	`48`	`+`
	`49`	`+ private LocalBuilder GetInitializedLocal(ILGenerator gen)`
	`50`	`+ {`
	`51`	`+ return local ??= gen.DeclareLocal(Type);`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,9 +38,5 @@ public Type Type`
`38`	`38`	`public abstract void Emit(ILGenerator gen);`
`39`	`39`
`40`	`40`	`public abstract void EmitStore(IExpression value, ILGenerator gen);`
`41`		`-`
`42`		`- public virtual void Generate(ILGenerator gen)`
`43`		`- {`
`44`		`- }`
`45`	`41`	`}`
`46`	`42`	`}`