Reference impls declare their own "owner" where appropriate

stakx · stakx · commit 50a7f6d79471 · 2025-12-16T01:30:11.000+01:00
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs
@@ -24,13 +24,13 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	internal class ArgumentReference : TypeReference
 	{
 		public ArgumentReference(Type argumentType)
-			: base(null, argumentType)
+			: base(argumentType)
 		{
 			Position = -1;
 		}
 
 		public ArgumentReference(Type argumentType, int position)
-			: base(null, argumentType)
+			: base(argumentType)
 		{
 			Position = position;
 		}
@@ -75,7 +75,6 @@ public override void StoreReference(IExpression value, ILGenerator gen)
 				throw new InvalidOperationException("ArgumentReference uninitialized");
 			}
 
-			OwnerReference?.Emit(gen);
 			value.Emit(gen);
 			gen.Emit(OpCodes.Starg, Position);
 		}
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeReference.cs
@@ -27,14 +27,9 @@ internal class AsTypeReference : Reference
 		private readonly Type type;
 
 		public AsTypeReference(Reference reference, Type type)
-			: base(SelfReference.Self)
 		{
 			this.reference = reference;
 			this.type = type;
-			if (reference == OwnerReference)
-			{
-				OwnerReference = null;
-			}
 		}
 
 		public override void LoadAddressOfReference(ILGenerator gen)
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs
@@ -27,7 +27,7 @@ internal class ByRefReference : TypeReference
 		private readonly LocalReference localReference;
 
 		public ByRefReference(LocalReference localReference)
-			: base(null, localReference.Type)
+			: base(localReference.Type)
 		{
 			this.localReference = localReference;
 		}
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs
@@ -28,25 +28,21 @@ internal class FieldReference : Reference
 		private readonly bool isStatic;
 
 		public FieldReference(FieldInfo field)
-			: base(SelfReference.Self)
 		{
 			this.field = field;
 			if ((field.Attributes & FieldAttributes.Static) != 0)
 			{
 				isStatic = true;
-				owner = null;
 			}
 		}
 
 		public FieldReference(FieldBuilder fieldBuilder)
-			: base(SelfReference.Self)
 		{
 			this.fieldBuilder = fieldBuilder;
 			field = fieldBuilder;
 			if ((fieldBuilder.Attributes & FieldAttributes.Static) != 0)
 			{
 				isStatic = true;
-				owner = null;
 			}
 		}
 
@@ -68,6 +64,7 @@ public override void LoadAddressOfReference(ILGenerator gen)
 			}
 			else
 			{
+				SelfReference.Self.Emit(gen);
 				gen.Emit(OpCodes.Ldflda, Reference);
 			}
 		}
@@ -80,20 +77,22 @@ public override void LoadReference(ILGenerator gen)
 			}
 			else
 			{
+				SelfReference.Self.Emit(gen);
 				gen.Emit(OpCodes.Ldfld, Reference);
 			}
 		}
 
 		public override void StoreReference(IExpression value, ILGenerator gen)
 		{
-			OwnerReference?.Emit(gen);
-			value.Emit(gen);
 			if (isStatic)
 			{
+				value.Emit(gen);
 				gen.Emit(OpCodes.Stsfld, Reference);
 			}
 			else
 			{
+				SelfReference.Self.Emit(gen);
+				value.Emit(gen);
 				gen.Emit(OpCodes.Stfld, Reference);
 			}
 		}
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs
@@ -28,30 +28,35 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	[DebuggerDisplay("&{OwnerReference}")]
 	internal class IndirectReference : TypeReference
 	{
-		public IndirectReference(TypeReference byRefReference) :
-			base(byRefReference, byRefReference.Type.GetElementType())
+		private readonly TypeReference byRefReference;
+
+		public IndirectReference(TypeReference byRefReference)
+			: base(byRefReference.Type.GetElementType())
 		{
 			if (!byRefReference.Type.IsByRef)
 			{
 				throw new ArgumentException("Expected an IsByRef reference", nameof(byRefReference));
 			}
+
+			this.byRefReference = byRefReference;
 		}
 
 		public override void LoadAddressOfReference(ILGenerator gen)
 		{
-			// Load of owner reference takes care of this.
+			byRefReference.Emit(gen);
 		}
 
 		// TODO: Better name
 
 		public override void LoadReference(ILGenerator gen)
 		{
+			byRefReference.Emit(gen);
 			OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, Type);
 		}
 
 		public override void StoreReference(IExpression value, ILGenerator gen)
 		{
-			OwnerReference?.Emit(gen);
+			byRefReference.Emit(gen);
 			value.Emit(gen);
 			OpCodeUtil.EmitStoreIndirectOpCodeForType(gen, Type);
 		}
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs
@@ -26,7 +26,7 @@ internal class LocalReference : TypeReference
 		private LocalBuilder? localBuilder;
 
 		public LocalReference(Type type)
-			: base(null, type)
+			: base(type)
 		{
 		}
 
@@ -47,7 +47,6 @@ public override void LoadReference(ILGenerator gen)
 
 		public override void StoreReference(IExpression value, ILGenerator gen)
 		{
-			OwnerReference?.Emit(gen);
 			value.Emit(gen);
 			gen.Emit(OpCodes.Stloc, localBuilder!);
 		}
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs
@@ -20,19 +20,6 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 
 	internal abstract class Reference : IExpression
 	{
-		protected Reference? owner;
-
-		protected Reference(Reference? owner)
-		{
-			this.owner = owner;
-		}
-
-		public Reference? OwnerReference
-		{
-			get { return owner; }
-			set { owner = value; }
-		}
-
 		public abstract void LoadAddressOfReference(ILGenerator gen);
 
 		public abstract void LoadReference(ILGenerator gen);
@@ -45,7 +32,6 @@ public virtual void Generate(ILGenerator gen)
 
 		public void Emit(ILGenerator gen)
 		{
-			OwnerReference?.Emit(gen);
 			LoadReference(gen);
 		}
 	}
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/SelfReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/SelfReference.cs
@@ -25,7 +25,7 @@ internal class SelfReference : Reference
 	{
 		public static readonly SelfReference Self = new SelfReference();
 
-		protected SelfReference() : base(null)
+		protected SelfReference()
 		{
 		}
 
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs
@@ -20,7 +20,7 @@ internal abstract class TypeReference : Reference
 	{
 		private readonly Type type;
 
-		protected TypeReference(Reference owner, Type type) : base(owner)
+		protected TypeReference(Type type)
 		{
 			this.type = type;
 		}

Original file line number	Diff line number	Diff line change
`@@ -24,13 +24,13 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST`
`24`	`24`	`internal class ArgumentReference : TypeReference`
`25`	`25`	`{`
`26`	`26`	`public ArgumentReference(Type argumentType)`
`27`		`- : base(null, argumentType)`
	`27`	`+ : base(argumentType)`
`28`	`28`	`{`
`29`	`29`	`Position = -1;`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`public ArgumentReference(Type argumentType, int position)`
`33`		`- : base(null, argumentType)`
	`33`	`+ : base(argumentType)`
`34`	`34`	`{`
`35`	`35`	`Position = position;`
`36`	`36`	`}`
`@@ -75,7 +75,6 @@ public override void StoreReference(IExpression value, ILGenerator gen)`
`75`	`75`	`throw new InvalidOperationException("ArgumentReference uninitialized");`
`76`	`76`	`}`
`77`	`77`
`78`		`- OwnerReference?.Emit(gen);`
`79`	`78`	`value.Emit(gen);`
`80`	`79`	`gen.Emit(OpCodes.Starg, Position);`
`81`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,14 +27,9 @@ internal class AsTypeReference : Reference`
`27`	`27`	`private readonly Type type;`
`28`	`28`
`29`	`29`	`public AsTypeReference(Reference reference, Type type)`
`30`		`- : base(SelfReference.Self)`
`31`	`30`	`{`
`32`	`31`	`this.reference = reference;`
`33`	`32`	`this.type = type;`
`34`		`- if (reference == OwnerReference)`
`35`		`- {`
`36`		`- OwnerReference = null;`
`37`		`- }`
`38`	`33`	`}`
`39`	`34`
`40`	`35`	`public override void LoadAddressOfReference(ILGenerator gen)`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ internal class ByRefReference : TypeReference`
`27`	`27`	`private readonly LocalReference localReference;`
`28`	`28`
`29`	`29`	`public ByRefReference(LocalReference localReference)`
`30`		`- : base(null, localReference.Type)`
	`30`	`+ : base(localReference.Type)`
`31`	`31`	`{`
`32`	`32`	`this.localReference = localReference;`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,25 +28,21 @@ internal class FieldReference : Reference`
`28`	`28`	`private readonly bool isStatic;`
`29`	`29`
`30`	`30`	`public FieldReference(FieldInfo field)`
`31`		`- : base(SelfReference.Self)`
`32`	`31`	`{`
`33`	`32`	`this.field = field;`
`34`	`33`	`if ((field.Attributes & FieldAttributes.Static) != 0)`
`35`	`34`	`{`
`36`	`35`	`isStatic = true;`
`37`		`- owner = null;`
`38`	`36`	`}`
`39`	`37`	`}`
`40`	`38`
`41`	`39`	`public FieldReference(FieldBuilder fieldBuilder)`
`42`		`- : base(SelfReference.Self)`
`43`	`40`	`{`
`44`	`41`	`this.fieldBuilder = fieldBuilder;`
`45`	`42`	`field = fieldBuilder;`
`46`	`43`	`if ((fieldBuilder.Attributes & FieldAttributes.Static) != 0)`
`47`	`44`	`{`
`48`	`45`	`isStatic = true;`
`49`		`- owner = null;`
`50`	`46`	`}`
`51`	`47`	`}`
`52`	`48`
`@@ -68,6 +64,7 @@ public override void LoadAddressOfReference(ILGenerator gen)`
`68`	`64`	`}`
`69`	`65`	`else`
`70`	`66`	`{`
	`67`	`+ SelfReference.Self.Emit(gen);`
`71`	`68`	`gen.Emit(OpCodes.Ldflda, Reference);`
`72`	`69`	`}`
`73`	`70`	`}`
`@@ -80,20 +77,22 @@ public override void LoadReference(ILGenerator gen)`
`80`	`77`	`}`
`81`	`78`	`else`
`82`	`79`	`{`
	`80`	`+ SelfReference.Self.Emit(gen);`
`83`	`81`	`gen.Emit(OpCodes.Ldfld, Reference);`
`84`	`82`	`}`
`85`	`83`	`}`
`86`	`84`
`87`	`85`	`public override void StoreReference(IExpression value, ILGenerator gen)`
`88`	`86`	`{`
`89`		`- OwnerReference?.Emit(gen);`
`90`		`- value.Emit(gen);`
`91`	`87`	`if (isStatic)`
`92`	`88`	`{`
	`89`	`+ value.Emit(gen);`
`93`	`90`	`gen.Emit(OpCodes.Stsfld, Reference);`
`94`	`91`	`}`
`95`	`92`	`else`
`96`	`93`	`{`
	`94`	`+ SelfReference.Self.Emit(gen);`
	`95`	`+ value.Emit(gen);`
`97`	`96`	`gen.Emit(OpCodes.Stfld, Reference);`
`98`	`97`	`}`
`99`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,30 +28,35 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST`
`28`	`28`	`[DebuggerDisplay("&{OwnerReference}")]`
`29`	`29`	`internal class IndirectReference : TypeReference`
`30`	`30`	`{`
`31`		`- public IndirectReference(TypeReference byRefReference) :`
`32`		`- base(byRefReference, byRefReference.Type.GetElementType())`
	`31`	`+ private readonly TypeReference byRefReference;`
	`32`	`+`
	`33`	`+ public IndirectReference(TypeReference byRefReference)`
	`34`	`+ : base(byRefReference.Type.GetElementType())`
`33`	`35`	`{`
`34`	`36`	`if (!byRefReference.Type.IsByRef)`
`35`	`37`	`{`
`36`	`38`	`throw new ArgumentException("Expected an IsByRef reference", nameof(byRefReference));`
`37`	`39`	`}`
	`40`	`+`
	`41`	`+ this.byRefReference = byRefReference;`
`38`	`42`	`}`
`39`	`43`
`40`	`44`	`public override void LoadAddressOfReference(ILGenerator gen)`
`41`	`45`	`{`
`42`		`- // Load of owner reference takes care of this.`
	`46`	`+ byRefReference.Emit(gen);`
`43`	`47`	`}`
`44`	`48`
`45`	`49`	`// TODO: Better name`
`46`	`50`
`47`	`51`	`public override void LoadReference(ILGenerator gen)`
`48`	`52`	`{`
	`53`	`+ byRefReference.Emit(gen);`
`49`	`54`	`OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, Type);`
`50`	`55`	`}`
`51`	`56`
`52`	`57`	`public override void StoreReference(IExpression value, ILGenerator gen)`
`53`	`58`	`{`
`54`		`- OwnerReference?.Emit(gen);`
	`59`	`+ byRefReference.Emit(gen);`
`55`	`60`	`value.Emit(gen);`
`56`	`61`	`OpCodeUtil.EmitStoreIndirectOpCodeForType(gen, Type);`
`57`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ internal class LocalReference : TypeReference`
`26`	`26`	`private LocalBuilder? localBuilder;`
`27`	`27`
`28`	`28`	`public LocalReference(Type type)`
`29`		`- : base(null, type)`
	`29`	`+ : base(type)`
`30`	`30`	`{`
`31`	`31`	`}`
`32`	`32`
`@@ -47,7 +47,6 @@ public override void LoadReference(ILGenerator gen)`
`47`	`47`
`48`	`48`	`public override void StoreReference(IExpression value, ILGenerator gen)`
`49`	`49`	`{`
`50`		`- OwnerReference?.Emit(gen);`
`51`	`50`	`value.Emit(gen);`
`52`	`51`	`gen.Emit(OpCodes.Stloc, localBuilder!);`
`53`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,19 +20,6 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST`
`20`	`20`
`21`	`21`	`internal abstract class Reference : IExpression`
`22`	`22`	`{`
`23`		`- protected Reference? owner;`
`24`		`-`
`25`		`- protected Reference(Reference? owner)`
`26`		`- {`
`27`		`- this.owner = owner;`
`28`		`- }`
`29`		`-`
`30`		`- public Reference? OwnerReference`
`31`		`- {`
`32`		`- get { return owner; }`
`33`		`- set { owner = value; }`
`34`		`- }`
`35`		`-`
`36`	`23`	`public abstract void LoadAddressOfReference(ILGenerator gen);`
`37`	`24`
`38`	`25`	`public abstract void LoadReference(ILGenerator gen);`
`@@ -45,7 +32,6 @@ public virtual void Generate(ILGenerator gen)`
`45`	`32`
`46`	`33`	`public void Emit(ILGenerator gen)`
`47`	`34`	`{`
`48`		`- OwnerReference?.Emit(gen);`
`49`	`35`	`LoadReference(gen);`
`50`	`36`	`}`
`51`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ internal class SelfReference : Reference`
`25`	`25`	`{`
`26`	`26`	`public static readonly SelfReference Self = new SelfReference();`
`27`	`27`
`28`		`- protected SelfReference() : base(null)`
	`28`	`+ protected SelfReference()`
`29`	`29`	`{`
`30`	`30`	`}`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ internal abstract class TypeReference : Reference`
`20`	`20`	`{`
`21`	`21`	`private readonly Type type;`
`22`	`22`
`23`		`- protected TypeReference(Reference owner, Type type) : base(owner)`
	`23`	`+ protected TypeReference(Type type)`
`24`	`24`	`{`
`25`	`25`	`this.type = type;`
`26`	`26`	`}`