From f05a7dc42db71dbfd4a0fea23f039cd764c536dd Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 17:58:54 +0100 Subject: [PATCH 01/22] Force explicit choice for `Reference.owner` --- .../Generators/Emitters/SimpleAST/AsTypeReference.cs | 1 + .../Generators/Emitters/SimpleAST/FieldReference.cs | 2 ++ .../Generators/Emitters/SimpleAST/Reference.cs | 12 +++++------- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeReference.cs index 6f0ce6c0ca..4f3c03a3fd 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeReference.cs @@ -25,6 +25,7 @@ internal class AsTypeReference : Reference private readonly Type type; public AsTypeReference(Reference reference, Type type) + : base(SelfReference.Self) { if (reference == null) { diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs index ebd0112df1..1b704995f3 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs @@ -26,6 +26,7 @@ internal class FieldReference : Reference private readonly bool isStatic; public FieldReference(FieldInfo field) + : base(SelfReference.Self) { this.field = field; if ((field.Attributes & FieldAttributes.Static) != 0) @@ -36,6 +37,7 @@ public FieldReference(FieldInfo field) } public FieldReference(FieldBuilder fieldBuilder) + : base(SelfReference.Self) { this.fieldBuilder = fieldBuilder; field = fieldBuilder; diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs index 6064317125..e972b1fa21 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs @@ -12,24 +12,22 @@ // See the License for the specific language governing permissions and // limitations under the License. +#nullable enable + namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST { using System.Reflection.Emit; internal abstract class Reference : IExpression { - protected Reference owner = SelfReference.Self; - - protected Reference() - { - } + protected Reference? owner; - protected Reference(Reference owner) + protected Reference(Reference? owner) { this.owner = owner; } - public Reference OwnerReference + public Reference? OwnerReference { get { return owner; } set { owner = value; } From 295ccc51ac47cd7ee2064b3a6baf152949c1f489 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 18:07:07 +0100 Subject: [PATCH 02/22] Force explicit choice for `TypeReference.owner` --- .../Generators/Emitters/SimpleAST/ArgumentReference.cs | 4 ++-- .../Generators/Emitters/SimpleAST/ByRefReference.cs | 2 +- .../Generators/Emitters/SimpleAST/LocalReference.cs | 3 ++- .../Generators/Emitters/SimpleAST/TypeReference.cs | 4 ---- 4 files changed, 5 insertions(+), 8 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs index 19be72db47..bc245f9b2f 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs @@ -22,13 +22,13 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST internal class ArgumentReference : TypeReference { public ArgumentReference(Type argumentType) - : base(argumentType) + : base(null, argumentType) { Position = -1; } public ArgumentReference(Type argumentType, int position) - : base(argumentType) + : base(null, argumentType) { Position = position; } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs index f6fc69ad5b..cb9e454e6a 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs @@ -25,7 +25,7 @@ internal class ByRefReference : TypeReference private readonly LocalReference localReference; public ByRefReference(LocalReference localReference) - : base(localReference.Type) + : base(null, localReference.Type) { this.localReference = localReference; } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs index 768bac77f3..00431ab71d 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs @@ -23,7 +23,8 @@ internal class LocalReference : TypeReference { private LocalBuilder localBuilder; - public LocalReference(Type type) : base(type) + public LocalReference(Type type) + : base(null, type) { } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs index fa551e64fc..2289bda216 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs @@ -20,10 +20,6 @@ internal abstract class TypeReference : Reference { private readonly Type type; - protected TypeReference(Type argumentType) : this(null, argumentType) - { - } - protected TypeReference(Reference owner, Type type) : base(owner) { this.type = type; From 3c90ed91a02d21b0cb03761d611e3bd9090fa3a0 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 18:04:50 +0100 Subject: [PATCH 03/22] Force explicit choice for `MethodInvocationExpression.owner` --- .../ClassProxySerializableContributor.cs | 1 + .../SimpleAST/MethodInvocationExpression.cs | 18 +++++------------- .../Generators/InvocationTypeGenerator.cs | 2 +- 3 files changed, 7 insertions(+), 14 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs index d5ba7a8bd9..4e22b04ad7 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs @@ -149,6 +149,7 @@ private void EmitCallToBaseGetObjectData(CodeBuilder codeBuilder, ArgumentRefere codeBuilder.AddStatement( new MethodInvocationExpression( + SelfReference.Self, baseGetObjectData, serializationInfo, streamingContext)); diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs index 4261758eea..c79961f6e0 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs @@ -12,6 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +#nullable enable + namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST { using System.Reflection; @@ -21,24 +23,14 @@ internal class MethodInvocationExpression : IExpression, IStatement { protected readonly IExpression[] args; protected readonly MethodInfo method; - protected readonly Reference owner; - - public MethodInvocationExpression(MethodInfo method, params IExpression[] args) : - this(SelfReference.Self, method, args) - { - } - - public MethodInvocationExpression(MethodEmitter method, params IExpression[] args) : - this(SelfReference.Self, method.MethodBuilder, args) - { - } + protected readonly Reference? owner; - public MethodInvocationExpression(Reference owner, MethodEmitter method, params IExpression[] args) : + public MethodInvocationExpression(Reference? owner, MethodEmitter method, params IExpression[] args) : this(owner, method.MethodBuilder, args) { } - public MethodInvocationExpression(Reference owner, MethodInfo method, params IExpression[] args) + public MethodInvocationExpression(Reference? owner, MethodInfo method, params IExpression[] args) { this.owner = owner; this.method = method; diff --git a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs index 0065584b7f..55014ecd86 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs @@ -289,7 +289,7 @@ private ConstructorEmitter CreateConstructor(AbstractTypeEmitter invocation, Arg private void EmitCallThrowOnNoTarget(MethodEmitter invokeMethodOnTarget) { - var throwOnNoTarget = new MethodInvocationExpression(InvocationMethods.ThrowOnNoTarget); + var throwOnNoTarget = new MethodInvocationExpression(SelfReference.Self, InvocationMethods.ThrowOnNoTarget); invokeMethodOnTarget.CodeBuilder.AddStatement(throwOnNoTarget); invokeMethodOnTarget.CodeBuilder.AddStatement(new ReturnStatement()); From 1848217b06b1b28dbbcffd9796674393bfc07cd4 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 18:14:35 +0100 Subject: [PATCH 04/22] Remove superfluous `MethodInvocationExpression` ctor --- .../Emitters/SimpleAST/MethodInvocationExpression.cs | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs index c79961f6e0..afa1adbb9c 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs @@ -25,11 +25,6 @@ internal class MethodInvocationExpression : IExpression, IStatement protected readonly MethodInfo method; protected readonly Reference? owner; - public MethodInvocationExpression(Reference? owner, MethodEmitter method, params IExpression[] args) : - this(owner, method.MethodBuilder, args) - { - } - public MethodInvocationExpression(Reference? owner, MethodInfo method, params IExpression[] args) { this.owner = owner; From cc782324b818697e9879daf11b8f7825ac15eb74 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 18:18:10 +0100 Subject: [PATCH 05/22] Downgrade `MethodInvocationExpression.owner` to an expression --- .../Emitters/SimpleAST/MethodInvocationExpression.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs index afa1adbb9c..2641bd0305 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/MethodInvocationExpression.cs @@ -23,9 +23,9 @@ internal class MethodInvocationExpression : IExpression, IStatement { protected readonly IExpression[] args; protected readonly MethodInfo method; - protected readonly Reference? owner; + protected readonly IExpression? owner; - public MethodInvocationExpression(Reference? owner, MethodInfo method, params IExpression[] args) + public MethodInvocationExpression(IExpression? owner, MethodInfo method, params IExpression[] args) { this.owner = owner; this.method = method; @@ -36,7 +36,7 @@ public MethodInvocationExpression(Reference? owner, MethodInfo method, params IE public void Emit(ILGenerator gen) { - ArgumentsUtil.EmitLoadOwnerAndReference(owner, gen); + owner?.Emit(gen); foreach (var exp in args) { From 2d456b4e3fb7f05bcb59c332097e255a809218f4 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 18:38:31 +0100 Subject: [PATCH 06/22] Downgrade contributors' & generators' `getTarget` to an expression --- .../ClassProxyTargetContributor.cs | 6 ++--- .../DynamicProxy/Contributors/Delegates.cs | 2 -- ...rfaceProxyWithOptionalTargetContributor.cs | 8 ++----- .../InterfaceProxyWithoutTargetContributor.cs | 6 ++--- ...nvocationWithGenericDelegateContributor.cs | 12 +++++----- .../Contributors/MixinContributor.cs | 6 ++--- .../ProxyTargetAccessorContributor.cs | 12 +++++----- .../Generators/ClassProxyGenerator.cs | 2 +- .../ClassProxyWithTargetGenerator.cs | 2 +- .../CompositionInvocationTypeGenerator.cs | 2 +- .../Generators/ForwardingMethodGenerator.cs | 10 ++++---- .../InheritanceInvocationTypeGenerator.cs | 2 +- .../InterfaceProxyWithTargetGenerator.cs | 2 +- ...erfaceProxyWithTargetInterfaceGenerator.cs | 11 +++------ .../InterfaceProxyWithoutTargetGenerator.cs | 2 +- .../Generators/InvocationTypeGenerator.cs | 4 ++-- .../MethodWithInvocationGenerator.cs | 24 +++++++++---------- .../OptionallyForwardingMethodGenerator.cs | 16 ++++++------- 18 files changed, 59 insertions(+), 70 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs index e60b4d08d2..0c0b71a066 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs @@ -78,13 +78,13 @@ protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEm var invocation = GetInvocationType(method, @class); - GetTargetExpressionDelegate getTargetTypeExpression = (c, m) => new TypeTokenExpression(targetType); + GetTargetExpressionDelegate getTargetType = (c, m) => new TypeTokenExpression(targetType); return new MethodWithInvocationGenerator(method, @class.GetField("__interceptors"), invocation, - getTargetTypeExpression, - getTargetTypeExpression, + getTargetType, + getTargetType, overrideMethod, null); } diff --git a/src/Castle.Core/DynamicProxy/Contributors/Delegates.cs b/src/Castle.Core/DynamicProxy/Contributors/Delegates.cs index 60a64d6173..ffab3c2e37 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/Delegates.cs +++ b/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); } \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithOptionalTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithOptionalTargetContributor.cs index 858a6fb205..ccf88663c1 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithOptionalTargetContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithOptionalTargetContributor.cs @@ -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); diff --git a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithoutTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithoutTargetContributor.cs index d450b39c4b..052a086eed 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithoutTargetContributor.cs +++ b/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 GetCollectors() @@ -56,7 +56,7 @@ protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEm return new MethodWithInvocationGenerator(method, @class.GetField("__interceptors"), invocation, - getTargetExpression, + getTarget, overrideMethod, null); } diff --git a/src/Castle.Core/DynamicProxy/Contributors/InvocationWithGenericDelegateContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InvocationWithGenericDelegateContributor.cs index 3dbeaf5fe7..f5b596d1d2 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/InvocationWithGenericDelegateContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/InvocationWithGenericDelegateContributor.cs @@ -29,14 +29,14 @@ internal class InvocationWithGenericDelegateContributor : IInvocationCreationCon { private readonly Type delegateType; private readonly MetaMethod method; - private readonly Reference targetReference; + private readonly IExpression target; - public InvocationWithGenericDelegateContributor(Type delegateType, MetaMethod method, Reference targetReference) + public InvocationWithGenericDelegateContributor(Type delegateType, MetaMethod method, IExpression target) { Debug.Assert(delegateType.IsGenericType, "delegateType.IsGenericType"); this.delegateType = delegateType; this.method = method; - this.targetReference = targetReference; + this.target = target; } public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation) @@ -69,18 +69,18 @@ private Reference GetDelegate(AbstractTypeEmitter invocation, MethodEmitter invo var localReference = invokeMethodOnTarget.CodeBuilder.DeclareLocal(closedDelegateType); var closedMethodOnTarget = method.MethodOnTarget.MakeGenericMethod(genericTypeParameters); invokeMethodOnTarget.CodeBuilder.AddStatement( - SetDelegate(localReference, targetReference, closedDelegateType, closedMethodOnTarget)); + SetDelegate(localReference, target, closedDelegateType, closedMethodOnTarget)); return localReference; } - private AssignStatement SetDelegate(LocalReference localDelegate, Reference localTarget, + private AssignStatement SetDelegate(LocalReference localDelegate, IExpression target, Type closedDelegateType, MethodInfo closedMethodOnTarget) { var delegateCreateDelegate = new MethodInvocationExpression( null, DelegateMethods.CreateDelegate, new TypeTokenExpression(closedDelegateType), - localTarget, + target, new MethodTokenExpression(closedMethodOnTarget)); return new AssignStatement(localDelegate, new ConvertExpression(closedDelegateType, delegateCreateDelegate)); } diff --git a/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs index e6070994ef..40b4e2877c 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs @@ -29,13 +29,13 @@ internal class MixinContributor : CompositeTypeContributor private readonly bool canChangeTarget; private readonly IList empty = new List(); private readonly IDictionary fields = new SortedDictionary(new FieldReferenceComparer()); - private readonly GetTargetExpressionDelegate getTargetExpression; + private readonly GetTargetExpressionDelegate getTarget; public MixinContributor(INamingScope namingScope, bool canChangeTarget) : base(namingScope) { this.canChangeTarget = canChangeTarget; - getTargetExpression = BuildGetTargetExpression(); + getTarget = BuildGetTargetExpression(); } public IEnumerable Fields @@ -101,7 +101,7 @@ protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEm return new MethodWithInvocationGenerator(method, @class.GetField("__interceptors"), invocation, - getTargetExpression, + getTarget, overrideMethod, null); } diff --git a/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs index fbdfbc0b58..963ab3bf76 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs @@ -25,12 +25,12 @@ namespace Castle.DynamicProxy.Contributors /// internal sealed class ProxyTargetAccessorContributor : ITypeContributor { - private readonly Func getTargetReference; + private readonly Func getTarget; private readonly Type targetType; - public ProxyTargetAccessorContributor(Func getTargetReference, Type targetType) + public ProxyTargetAccessorContributor(Func getTarget, Type targetType) { - this.getTargetReference = getTargetReference; + this.getTarget = getTarget; this.targetType = targetType; } @@ -41,17 +41,17 @@ public void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model) public void Generate(ClassEmitter emitter) { var interceptorsField = emitter.GetField("__interceptors"); - var targetReference = getTargetReference(); + var target = getTarget(); var dynProxyGetTarget = emitter.CreateMethod(nameof(IProxyTargetAccessor.DynProxyGetTarget), typeof(object)); dynProxyGetTarget.CodeBuilder.AddStatement( - new ReturnStatement(new ConvertExpression(typeof(object), targetType, targetReference))); + new ReturnStatement(new ConvertExpression(typeof(object), targetType, target))); var dynProxySetTarget = emitter.CreateMethod(nameof(IProxyTargetAccessor.DynProxySetTarget), typeof(void), typeof(object)); // we can only change the target of the interface proxy - if (targetReference is FieldReference targetField) + if (target is FieldReference targetField) { dynProxySetTarget.CodeBuilder.AddStatement( new AssignStatement(targetField, diff --git a/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs index 7d713f15dc..665452b66d 100644 --- a/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs @@ -51,7 +51,7 @@ protected override CompositeTypeContributor GetProxyTargetContributor(INamingSco protected override ProxyTargetAccessorContributor GetProxyTargetAccessorContributor() { return new ProxyTargetAccessorContributor( - getTargetReference: () => SelfReference.Self, + getTarget: () => SelfReference.Self, targetType); } } diff --git a/src/Castle.Core/DynamicProxy/Generators/ClassProxyWithTargetGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/ClassProxyWithTargetGenerator.cs index c7f6fe6ad5..97232d624c 100644 --- a/src/Castle.Core/DynamicProxy/Generators/ClassProxyWithTargetGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/ClassProxyWithTargetGenerator.cs @@ -65,7 +65,7 @@ protected override CompositeTypeContributor GetProxyTargetContributor(INamingSco protected override ProxyTargetAccessorContributor GetProxyTargetAccessorContributor() { return new ProxyTargetAccessorContributor( - getTargetReference: () => targetField, + getTarget: () => targetField, targetType); } diff --git a/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs index 7222725f31..f93617272c 100644 --- a/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs @@ -52,7 +52,7 @@ protected override Type GetBaseType() return BaseType; } - protected override FieldReference GetTargetReference() + protected override FieldReference GetTargetField() { return new FieldReference(InvocationMethods.CompositionInvocationTarget); } diff --git a/src/Castle.Core/DynamicProxy/Generators/ForwardingMethodGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/ForwardingMethodGenerator.cs index 6b7364f6e5..8af47db319 100644 --- a/src/Castle.Core/DynamicProxy/Generators/ForwardingMethodGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/ForwardingMethodGenerator.cs @@ -20,24 +20,24 @@ namespace Castle.DynamicProxy.Generators internal class ForwardingMethodGenerator : MethodGenerator { - private readonly GetTargetReferenceDelegate getTargetReference; + private readonly GetTargetExpressionDelegate getTarget; public ForwardingMethodGenerator(MetaMethod method, OverrideMethodDelegate overrideMethod, - GetTargetReferenceDelegate getTargetReference) + GetTargetExpressionDelegate getTarget) : base(method, overrideMethod) { - this.getTargetReference = getTargetReference; + this.getTarget = getTarget; } protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, INamingScope namingScope) { - var targetReference = getTargetReference(@class, MethodToOverride); + var target = getTarget(@class, MethodToOverride); var arguments = ArgumentsUtil.ConvertToArgumentReferenceExpression(MethodToOverride.GetParameters()); emitter.CodeBuilder.AddStatement(new ReturnStatement( new MethodInvocationExpression( - targetReference, + target, MethodToOverride, arguments) { VirtualCall = true })); return emitter; diff --git a/src/Castle.Core/DynamicProxy/Generators/InheritanceInvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InheritanceInvocationTypeGenerator.cs index b02d5876e9..2ea9356782 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InheritanceInvocationTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InheritanceInvocationTypeGenerator.cs @@ -51,7 +51,7 @@ protected override Type GetBaseType() return BaseType; } - protected override FieldReference GetTargetReference() + protected override FieldReference GetTargetField() { return new FieldReference(InvocationMethods.ProxyObject); } diff --git a/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetGenerator.cs index dc4ac91c41..083994281c 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetGenerator.cs @@ -40,7 +40,7 @@ protected override CompositeTypeContributor GetProxyTargetContributor(Type proxy protected override ProxyTargetAccessorContributor GetProxyTargetAccessorContributor() { return new ProxyTargetAccessorContributor( - getTargetReference: () => targetField, + getTarget: () => targetField, proxyTargetType); } diff --git a/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetInterfaceGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetInterfaceGenerator.cs index 9ae7b102c9..fdd165a8f2 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetInterfaceGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetInterfaceGenerator.cs @@ -44,7 +44,7 @@ protected override CompositeTypeContributor GetProxyTargetContributor(Type proxy protected override ProxyTargetAccessorContributor GetProxyTargetAccessorContributor() { return new ProxyTargetAccessorContributor( - getTargetReference: () => targetField, + getTarget: () => targetField, proxyTargetType); } @@ -57,18 +57,13 @@ protected override void AddMappingForAdditionalInterfaces(CompositeTypeContribut protected override InterfaceProxyWithoutTargetContributor GetContributorForAdditionalInterfaces( INamingScope namingScope) { - return new InterfaceProxyWithOptionalTargetContributor(namingScope, GetTargetExpression, GetTarget) + return new InterfaceProxyWithOptionalTargetContributor(namingScope, GetTarget) { Logger = Logger }; } - private Reference GetTarget(ClassEmitter @class, MethodInfo method) + private IExpression GetTarget(ClassEmitter @class, MethodInfo method) { return new AsTypeReference(@class.GetField("__target"), method.DeclaringType); } - - private IExpression GetTargetExpression(ClassEmitter @class, MethodInfo method) - { - return GetTarget(@class, method); - } } } \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithoutTargetGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithoutTargetGenerator.cs index d916e4dc62..845d1a81b3 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithoutTargetGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithoutTargetGenerator.cs @@ -41,7 +41,7 @@ protected override CompositeTypeContributor GetProxyTargetContributor(Type proxy protected override ProxyTargetAccessorContributor GetProxyTargetAccessorContributor() { return new ProxyTargetAccessorContributor( - getTargetReference: () => targetField, + getTarget: () => targetField, proxyTargetType); } diff --git a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs index 55014ecd86..d4630a6e8b 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs @@ -51,7 +51,7 @@ protected abstract ArgumentReference[] GetBaseCtorArguments(Type targetFieldType protected abstract Type GetBaseType(); - protected abstract FieldReference GetTargetReference(); + protected abstract FieldReference GetTargetField(); public AbstractTypeEmitter Generate(ClassEmitter @class, INamingScope namingScope) { @@ -71,7 +71,7 @@ public AbstractTypeEmitter Generate(ClassEmitter @class, INamingScope namingScop CreateConstructor(invocation); - var targetField = GetTargetReference(); + var targetField = GetTargetField(); if (canChangeTarget) { ImplementChangeProxyTargetInterface(@class, invocation, targetField); diff --git a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs index 184c0ce484..89102ab4ee 100644 --- a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs @@ -32,27 +32,27 @@ namespace Castle.DynamicProxy.Generators internal class MethodWithInvocationGenerator : MethodGenerator { private readonly IInvocationCreationContributor contributor; - private readonly GetTargetExpressionDelegate getTargetExpression; - private readonly GetTargetExpressionDelegate getTargetTypeExpression; + private readonly GetTargetExpressionDelegate getTarget; + private readonly GetTargetExpressionDelegate getTargetType; private readonly IExpression interceptors; private readonly Type invocation; public MethodWithInvocationGenerator(MetaMethod method, IExpression interceptors, Type invocation, - GetTargetExpressionDelegate getTargetExpression, + GetTargetExpressionDelegate getTarget, OverrideMethodDelegate createMethod, IInvocationCreationContributor contributor) - : this(method, interceptors, invocation, getTargetExpression, null, createMethod, contributor) + : this(method, interceptors, invocation, getTarget, null, createMethod, contributor) { } public MethodWithInvocationGenerator(MetaMethod method, IExpression interceptors, Type invocation, - GetTargetExpressionDelegate getTargetExpression, - GetTargetExpressionDelegate getTargetTypeExpression, + GetTargetExpressionDelegate getTarget, + GetTargetExpressionDelegate getTargetType, OverrideMethodDelegate createMethod, IInvocationCreationContributor contributor) : base(method, createMethod) { this.invocation = invocation; - this.getTargetExpression = getTargetExpression; - this.getTargetTypeExpression = getTargetTypeExpression; + this.getTarget = getTarget; + this.getTargetType = getTargetType; this.interceptors = interceptors; this.contributor = contributor; } @@ -189,13 +189,13 @@ private IExpression SetMethodInterceptors(ClassEmitter @class, INamingScope nami var methodInterceptorsField = BuildMethodInterceptorsField(@class, MethodToOverride, namingScope); IExpression targetTypeExpression; - if (getTargetTypeExpression != null) + if (getTargetType != null) { - targetTypeExpression = getTargetTypeExpression(@class, MethodToOverride); + targetTypeExpression = getTargetType(@class, MethodToOverride); } else { - targetTypeExpression = new MethodInvocationExpression(null, TypeUtilMethods.GetTypeOrNull, getTargetExpression(@class, MethodToOverride)); + targetTypeExpression = new MethodInvocationExpression(null, TypeUtilMethods.GetTypeOrNull, getTarget(@class, MethodToOverride)); } var emptyInterceptors = new NewArrayExpression(0, typeof(IInterceptor)); @@ -234,7 +234,7 @@ private IExpression[] GetCtorArguments(ClassEmitter @class, IExpression proxiedM { return new[] { - getTargetExpression(@class, MethodToOverride), + getTarget(@class, MethodToOverride), SelfReference.Self, methodInterceptors ?? interceptors, proxiedMethodTokenExpression, diff --git a/src/Castle.Core/DynamicProxy/Generators/OptionallyForwardingMethodGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/OptionallyForwardingMethodGenerator.cs index 51a36f2f73..6f8dc480fe 100644 --- a/src/Castle.Core/DynamicProxy/Generators/OptionallyForwardingMethodGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/OptionallyForwardingMethodGenerator.cs @@ -24,37 +24,37 @@ namespace Castle.DynamicProxy.Generators internal class OptionallyForwardingMethodGenerator : MethodGenerator { // TODO: This class largely duplicates code from Forwarding and Minimalistic generators. Should be refactored to change that - private readonly GetTargetReferenceDelegate getTargetReference; + private readonly GetTargetExpressionDelegate getTarget; public OptionallyForwardingMethodGenerator(MetaMethod method, OverrideMethodDelegate overrideMethod, - GetTargetReferenceDelegate getTargetReference) + GetTargetExpressionDelegate getTarget) : base(method, overrideMethod) { - this.getTargetReference = getTargetReference; + this.getTarget = getTarget; } protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, INamingScope namingScope) { - var targetReference = getTargetReference(@class, MethodToOverride); + var target = getTarget(@class, MethodToOverride); emitter.CodeBuilder.AddStatement( new IfNullExpression( - targetReference, + target, IfNull(emitter.ReturnType), - IfNotNull(targetReference))); + IfNotNull(target))); return emitter; } - private IStatement IfNotNull(Reference targetReference) + private IStatement IfNotNull(IExpression target) { var statements = new BlockStatement(); var arguments = ArgumentsUtil.ConvertToArgumentReferenceExpression(MethodToOverride.GetParameters()); statements.AddStatement(new ReturnStatement( new MethodInvocationExpression( - targetReference, + target, MethodToOverride, arguments) { VirtualCall = true })); return statements; From 54343bc501799459b320eaeab715f802bfbc92f9 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 18:48:10 +0100 Subject: [PATCH 07/22] Downgrade `AsTypeReference` to an expression & rename it --- .../Contributors/MixinContributor.cs | 2 +- ...AsTypeReference.cs => AsTypeExpression.cs} | 35 +++++-------------- ...erfaceProxyWithTargetInterfaceGenerator.cs | 2 +- .../Generators/InvocationTypeGenerator.cs | 2 +- 4 files changed, 12 insertions(+), 29 deletions(-) rename src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/{AsTypeReference.cs => AsTypeExpression.cs} (54%) diff --git a/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs index 40b4e2877c..e633b47348 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs @@ -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]); } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeExpression.cs similarity index 54% rename from src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeReference.cs rename to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeExpression.cs index 4f3c03a3fd..7ea4081d72 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AsTypeExpression.cs @@ -18,47 +18,30 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST using System.Diagnostics; using System.Reflection.Emit; - [DebuggerDisplay("{reference} as {type}")] - internal class AsTypeReference : Reference + [DebuggerDisplay("{expression} as {type}")] + internal class AsTypeExpression : IExpression { - private readonly Reference reference; + private readonly IExpression expression; private readonly Type type; - public AsTypeReference(Reference reference, Type type) - : base(SelfReference.Self) + public AsTypeExpression(IExpression expression, Type type) { - if (reference == null) + if (expression == null) { - throw new ArgumentNullException(nameof(reference)); + throw new ArgumentNullException(nameof(AsTypeExpression.expression)); } if (type == null) { throw new ArgumentNullException(nameof(type)); } - this.reference = reference; + this.expression = expression; this.type = type; - if (reference == OwnerReference) - { - OwnerReference = null; - } - } - - public override void LoadAddressOfReference(ILGenerator gen) - { - // NOTE: Or maybe throw new NotSupportedException() ? - reference.LoadAddressOfReference(gen); } - public override void LoadReference(ILGenerator gen) + public void Emit(ILGenerator gen) { - reference.LoadReference(gen); + expression.Emit(gen); gen.Emit(OpCodes.Isinst, type); } - - public override void StoreReference(ILGenerator gen) - { - // NOTE: Or maybe throw new NotSupportedException() ? - reference.StoreReference(gen); - } } } \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetInterfaceGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetInterfaceGenerator.cs index fdd165a8f2..472aa48c98 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetInterfaceGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetInterfaceGenerator.cs @@ -63,7 +63,7 @@ protected override InterfaceProxyWithoutTargetContributor GetContributorForAddit private IExpression GetTarget(ClassEmitter @class, MethodInfo method) { - return new AsTypeReference(@class.GetField("__target"), method.DeclaringType); + return new AsTypeExpression(@class.GetField("__target"), method.DeclaringType); } } } \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs index d4630a6e8b..5c51b64232 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs @@ -96,7 +96,7 @@ protected virtual MethodInvocationExpression GetCallbackMethodInvocation(Abstrac return contributor.GetCallbackMethodInvocation(invocation, args, targetField, invokeMethodOnTarget); } var methodOnTargetInvocationExpression = new MethodInvocationExpression( - new AsTypeReference(targetField, callbackMethod.DeclaringType), + new AsTypeExpression(targetField, callbackMethod.DeclaringType), callbackMethod, args) { VirtualCall = true }; return methodOnTargetInvocationExpression; From ce09a899817d2d62afa58d30b2e15e6b9a524014 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 18:53:25 +0100 Subject: [PATCH 08/22] `Reference` does not need a recursive owner chain --- .../DynamicProxy/Generators/Emitters/ArgumentsUtil.cs | 2 +- .../Generators/Emitters/SimpleAST/AssignStatement.cs | 2 +- .../DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs | 6 +++--- .../Generators/Emitters/SimpleAST/TypeReference.cs | 3 ++- 4 files changed, 7 insertions(+), 6 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs index 2e0396df26..b5743c3072 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs @@ -65,7 +65,7 @@ public static void EmitLoadOwnerAndReference(Reference reference, ILGenerator il return; } - EmitLoadOwnerAndReference(reference.OwnerReference, il); + reference.Owner?.Emit(il); reference.LoadReference(il); } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs index 4d33b78ac9..947e8e876b 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs @@ -29,7 +29,7 @@ public AssignStatement(Reference target, IExpression expression) public void Emit(ILGenerator gen) { - ArgumentsUtil.EmitLoadOwnerAndReference(target.OwnerReference, gen); + target.Owner?.Emit(gen); expression.Emit(gen); target.StoreReference(gen); } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs index e972b1fa21..5e1c2b14eb 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs @@ -20,14 +20,14 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST internal abstract class Reference : IExpression { - protected Reference? owner; + protected IExpression? owner; - protected Reference(Reference? owner) + protected Reference(IExpression? owner) { this.owner = owner; } - public Reference? OwnerReference + public IExpression? Owner { get { return owner; } set { owner = value; } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs index 2289bda216..e07ad82173 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs @@ -20,7 +20,8 @@ internal abstract class TypeReference : Reference { private readonly Type type; - protected TypeReference(Reference owner, Type type) : base(owner) + protected TypeReference(IExpression owner, Type type) + : base(owner) { this.type = type; } From 2e31b943a53b05cb2f34dce7d097f1275a672d9e Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 18:54:59 +0100 Subject: [PATCH 09/22] Downgrade `SelfReference` to an expression & rename it --- .../ClassProxySerializableContributor.cs | 4 ++-- .../ClassProxyTargetContributor.cs | 2 +- .../InterfaceProxyWithoutTargetContributor.cs | 2 +- .../Generators/ClassProxyGenerator.cs | 2 +- .../CompositionInvocationTypeGenerator.cs | 2 +- .../Emitters/SimpleAST/FieldReference.cs | 4 ++-- .../{SelfReference.cs => ThisExpression.cs} | 19 ++++--------------- .../Generators/InvocationTypeGenerator.cs | 10 +++++----- .../MethodWithInvocationGenerator.cs | 2 +- 9 files changed, 18 insertions(+), 29 deletions(-) rename src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/{SelfReference.cs => ThisExpression.cs} (66%) diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs index 4e22b04ad7..87daeda950 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs @@ -129,7 +129,7 @@ private void EmitCustomGetObjectData(CodeBuilder codeBuilder, ArgumentReference var getObjectData = new MethodInvocationExpression( null, FormatterServicesMethods.GetObjectData, - SelfReference.Self, + ThisExpression.Instance, members); codeBuilder.AddStatement(new AssignStatement(data, getObjectData)); @@ -149,7 +149,7 @@ private void EmitCallToBaseGetObjectData(CodeBuilder codeBuilder, ArgumentRefere codeBuilder.AddStatement( new MethodInvocationExpression( - SelfReference.Self, + ThisExpression.Instance, baseGetObjectData, serializationInfo, streamingContext)); diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs index 0c0b71a066..d865eebe92 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs @@ -122,7 +122,7 @@ private MethodBuilder CreateCallbackMethod(ClassEmitter emitter, MethodInfo meth callBackMethod.CodeBuilder.AddStatement( new ReturnStatement( - new MethodInvocationExpression(SelfReference.Self, + new MethodInvocationExpression(ThisExpression.Instance, targetMethod, callBackMethod.Arguments))); diff --git a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithoutTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithoutTargetContributor.cs index 052a086eed..50bda083e0 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithoutTargetContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyWithoutTargetContributor.cs @@ -119,7 +119,7 @@ private MethodInfo CreateCallbackMethod(ClassEmitter emitter, MethodInfo methodI callBackMethod.CodeBuilder.AddStatement( new ReturnStatement( - new MethodInvocationExpression(SelfReference.Self, targetMethod, callBackMethod.Arguments))); + new MethodInvocationExpression(ThisExpression.Instance, targetMethod, callBackMethod.Arguments))); return callBackMethod.MethodBuilder; } diff --git a/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs index 665452b66d..dbd9af7221 100644 --- a/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs @@ -51,7 +51,7 @@ protected override CompositeTypeContributor GetProxyTargetContributor(INamingSco protected override ProxyTargetAccessorContributor GetProxyTargetAccessorContributor() { return new ProxyTargetAccessorContributor( - getTarget: () => SelfReference.Self, + getTarget: () => ThisExpression.Instance, targetType); } } diff --git a/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs index f93617272c..f5f6975e21 100644 --- a/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs @@ -62,7 +62,7 @@ protected override void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invoca { invokeMethodOnTarget.CodeBuilder.AddStatement( new MethodInvocationExpression( - SelfReference.Self, + ThisExpression.Instance, InvocationMethods.CompositionInvocationEnsureValidTarget)); base.ImplementInvokeMethodOnTarget(invocation, parameters, invokeMethodOnTarget, targetField); diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs index 1b704995f3..86e28fce23 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs @@ -26,7 +26,7 @@ internal class FieldReference : Reference private readonly bool isStatic; public FieldReference(FieldInfo field) - : base(SelfReference.Self) + : base(ThisExpression.Instance) { this.field = field; if ((field.Attributes & FieldAttributes.Static) != 0) @@ -37,7 +37,7 @@ public FieldReference(FieldInfo field) } public FieldReference(FieldBuilder fieldBuilder) - : base(SelfReference.Self) + : base(ThisExpression.Instance) { this.fieldBuilder = fieldBuilder; field = fieldBuilder; diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/SelfReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ThisExpression.cs similarity index 66% rename from src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/SelfReference.cs rename to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ThisExpression.cs index 085d964da1..a9b3046912 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/SelfReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ThisExpression.cs @@ -14,30 +14,19 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST { - using System; using System.Diagnostics; using System.Reflection.Emit; [DebuggerDisplay("this")] - internal class SelfReference : Reference + internal class ThisExpression : IExpression { - public static readonly SelfReference Self = new SelfReference(); + public static readonly ThisExpression Instance = new ThisExpression(); - protected SelfReference() : base(null) + protected ThisExpression() { } - public override void LoadAddressOfReference(ILGenerator gen) - { - throw new NotSupportedException(); - } - - public override void LoadReference(ILGenerator gen) - { - gen.Emit(OpCodes.Ldarg_0); - } - - public override void StoreReference(ILGenerator gen) + public void Emit(ILGenerator gen) { gen.Emit(OpCodes.Ldarg_0); } diff --git a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs index 5c51b64232..299ca35fc4 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs @@ -143,7 +143,7 @@ protected virtual void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocat #endif { localValue = new ConvertExpression(paramType.GetElementType(), - new MethodInvocationExpression(SelfReference.Self, + new MethodInvocationExpression(ThisExpression.Instance, InvocationMethods.GetArgumentValue, new LiteralIntExpression(i))); } @@ -170,7 +170,7 @@ protected virtual void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocat { args[i] = new ConvertExpression(paramType, - new MethodInvocationExpression(SelfReference.Self, + new MethodInvocationExpression(ThisExpression.Instance, InvocationMethods.GetArgumentValue, new LiteralIntExpression(i))); } @@ -218,7 +218,7 @@ protected virtual void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocat } var setRetVal = - new MethodInvocationExpression(SelfReference.Self, + new MethodInvocationExpression(ThisExpression.Instance, InvocationMethods.SetReturnValue, retVal); @@ -260,7 +260,7 @@ private void AssignBackByRefArguments(MethodEmitter invokeMethodOnTarget, Dictio invokeMethodOnTarget.CodeBuilder.AddStatement( new MethodInvocationExpression( - SelfReference.Self, + ThisExpression.Instance, InvocationMethods.SetArgumentValue, new LiteralIntExpression(index), localValue)); @@ -289,7 +289,7 @@ private ConstructorEmitter CreateConstructor(AbstractTypeEmitter invocation, Arg private void EmitCallThrowOnNoTarget(MethodEmitter invokeMethodOnTarget) { - var throwOnNoTarget = new MethodInvocationExpression(SelfReference.Self, InvocationMethods.ThrowOnNoTarget); + var throwOnNoTarget = new MethodInvocationExpression(ThisExpression.Instance, InvocationMethods.ThrowOnNoTarget); invokeMethodOnTarget.CodeBuilder.AddStatement(throwOnNoTarget); invokeMethodOnTarget.CodeBuilder.AddStatement(new ReturnStatement()); diff --git a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs index 89102ab4ee..3deb447ffa 100644 --- a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs @@ -235,7 +235,7 @@ private IExpression[] GetCtorArguments(ClassEmitter @class, IExpression proxiedM return new[] { getTarget(@class, MethodToOverride), - SelfReference.Self, + ThisExpression.Instance, methodInterceptors ?? interceptors, proxiedMethodTokenExpression, new ReferencesToObjectArrayExpression(dereferencedArguments) From 89795bf6e9df9699bcd15cba4e2ca88716a9a43e Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 19:00:08 +0100 Subject: [PATCH 10/22] Merge `TypeReference` into `Reference` --- .../Emitters/SimpleAST/ArgumentReference.cs | 2 +- .../Emitters/SimpleAST/ByRefReference.cs | 2 +- .../Emitters/SimpleAST/FieldReference.cs | 4 +-- .../Emitters/SimpleAST/IndirectReference.cs | 10 +++--- .../Emitters/SimpleAST/LocalReference.cs | 2 +- .../Emitters/SimpleAST/Reference.cs | 10 +++++- .../ReferencesToObjectArrayExpression.cs | 4 +-- .../Emitters/SimpleAST/TypeReference.cs | 34 ------------------- .../DynamicProxy/Generators/GeneratorUtil.cs | 6 ++-- .../MethodWithInvocationGenerator.cs | 2 +- 10 files changed, 25 insertions(+), 51 deletions(-) delete mode 100644 src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs index bc245f9b2f..25e6bb02c4 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs @@ -19,7 +19,7 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST using System.Reflection.Emit; [DebuggerDisplay("argument {Type}")] - internal class ArgumentReference : TypeReference + internal class ArgumentReference : Reference { public ArgumentReference(Type argumentType) : base(null, argumentType) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs index cb9e454e6a..3e238f46f8 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs @@ -20,7 +20,7 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST [DebuggerDisplay("&{localReference}")] - internal class ByRefReference : TypeReference + internal class ByRefReference : Reference { private readonly LocalReference localReference; diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs index 86e28fce23..ab02547396 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs @@ -26,7 +26,7 @@ internal class FieldReference : Reference private readonly bool isStatic; public FieldReference(FieldInfo field) - : base(ThisExpression.Instance) + : base(ThisExpression.Instance, field.FieldType) { this.field = field; if ((field.Attributes & FieldAttributes.Static) != 0) @@ -37,7 +37,7 @@ public FieldReference(FieldInfo field) } public FieldReference(FieldBuilder fieldBuilder) - : base(ThisExpression.Instance) + : base(ThisExpression.Instance, fieldBuilder.FieldType) { this.fieldBuilder = fieldBuilder; field = fieldBuilder; diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs index 321d43954d..1e721c281c 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs @@ -24,9 +24,9 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST /// ByRef and provides indirect load/store support. /// [DebuggerDisplay("&{OwnerReference}")] - internal class IndirectReference : TypeReference + internal class IndirectReference : Reference { - public IndirectReference(TypeReference byRefReference) : + public IndirectReference(Reference byRefReference) : base(byRefReference, byRefReference.Type.GetElementType()) { if (!byRefReference.Type.IsByRef) @@ -52,15 +52,15 @@ public override void StoreReference(ILGenerator gen) OpCodeUtil.EmitStoreIndirectOpCodeForType(gen, Type); } - public static TypeReference WrapIfByRef(TypeReference reference) + public static Reference WrapIfByRef(Reference reference) { return reference.Type.IsByRef ? new IndirectReference(reference) : reference; } // TODO: Better name - public static TypeReference[] WrapIfByRef(TypeReference[] references) + public static Reference[] WrapIfByRef(Reference[] references) { - var result = new TypeReference[references.Length]; + var result = new Reference[references.Length]; for (var i = 0; i < references.Length; i++) { diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs index 00431ab71d..2c7c902e4e 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs @@ -19,7 +19,7 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST using System.Reflection.Emit; [DebuggerDisplay("local {Type}")] - internal class LocalReference : TypeReference + internal class LocalReference : Reference { private LocalBuilder localBuilder; diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs index 5e1c2b14eb..c0187029db 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs @@ -16,15 +16,18 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST { + using System; using System.Reflection.Emit; internal abstract class Reference : IExpression { protected IExpression? owner; + protected readonly Type type; - protected Reference(IExpression? owner) + protected Reference(IExpression? owner, Type type) { this.owner = owner; + this.type = type; } public IExpression? Owner @@ -33,6 +36,11 @@ public IExpression? Owner set { owner = value; } } + public Type Type + { + get { return type; } + } + public abstract void LoadAddressOfReference(ILGenerator gen); public abstract void LoadReference(ILGenerator gen); diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs index a611fd54f4..e776d8b8db 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs @@ -22,9 +22,9 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST internal class ReferencesToObjectArrayExpression : IExpression { - private readonly TypeReference[] args; + private readonly Reference[] args; - public ReferencesToObjectArrayExpression(params TypeReference[] args) + public ReferencesToObjectArrayExpression(params Reference[] args) { this.args = args; } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs deleted file mode 100644 index e07ad82173..0000000000 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeReference.cs +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright 2004-2021 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; - - internal abstract class TypeReference : Reference - { - private readonly Type type; - - protected TypeReference(IExpression owner, Type type) - : base(owner) - { - this.type = type; - } - - public Type Type - { - get { return type; } - } - } -} \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.cs b/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.cs index 97a221a6a0..d711af5934 100644 --- a/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.cs +++ b/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.cs @@ -25,7 +25,7 @@ namespace Castle.DynamicProxy.Generators internal static class GeneratorUtil { - public static void CopyOutAndRefParameters(TypeReference[] dereferencedArguments, LocalReference invocation, + public static void CopyOutAndRefParameters(Reference[] dereferencedArguments, LocalReference invocation, MethodInfo method, MethodEmitter emitter) { var parameters = method.GetParameters(); @@ -131,12 +131,12 @@ bool IsReadOnly(ParameterInfo parameter) } } - private static ConvertExpression Argument(int i, LocalReference invocationArgs, TypeReference[] arguments) + private static ConvertExpression Argument(int i, LocalReference invocationArgs, Reference[] arguments) { return new ConvertExpression(arguments[i].Type, new LoadRefArrayElementExpression(i, invocationArgs)); } - private static AssignStatement AssignArgument(TypeReference[] dereferencedArguments, int i, + private static AssignStatement AssignArgument(Reference[] dereferencedArguments, int i, LocalReference invocationArgs) { return new AssignStatement(dereferencedArguments[i], Argument(i, invocationArgs, dereferencedArguments)); diff --git a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs index 3deb447ffa..36313d68d5 100644 --- a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs @@ -230,7 +230,7 @@ private void EmitLoadGenericMethodArguments(MethodEmitter methodEmitter, MethodI genericParamsArrayLocal)); } - private IExpression[] GetCtorArguments(ClassEmitter @class, IExpression proxiedMethodTokenExpression, TypeReference[] dereferencedArguments, IExpression methodInterceptors) + private IExpression[] GetCtorArguments(ClassEmitter @class, IExpression proxiedMethodTokenExpression, Reference[] dereferencedArguments, IExpression methodInterceptors) { return new[] { From c91cc9d22fd2db7c5187d6d5664663f903412a67 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 19:04:07 +0100 Subject: [PATCH 11/22] Merge `ArgumentsUtil.EmitLoadOwnerAndReference` into `Reference` --- .../Generators/Emitters/ArgumentsUtil.cs | 12 ------------ .../Emitters/SimpleAST/AssignArgumentStatement.cs | 2 +- .../Emitters/SimpleAST/AssignArrayStatement.cs | 2 +- .../Emitters/SimpleAST/IfNullExpression.cs | 2 +- .../SimpleAST/LoadRefArrayElementExpression.cs | 2 +- .../Generators/Emitters/SimpleAST/Reference.cs | 3 ++- .../SimpleAST/ReferencesToObjectArrayExpression.cs | 2 +- .../Generators/Emitters/SimpleAST/ReturnStatement.cs | 2 +- 8 files changed, 8 insertions(+), 19 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs index b5743c3072..8d91038bc1 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs @@ -58,18 +58,6 @@ public static IExpression[] ConvertToArgumentReferenceExpression(ParameterInfo[] return arguments; } - public static void EmitLoadOwnerAndReference(Reference reference, ILGenerator il) - { - if (reference == null) - { - return; - } - - reference.Owner?.Emit(il); - - reference.LoadReference(il); - } - public static Type[] GetTypes(ParameterInfo[] parameters) { var types = new Type[parameters.Length]; diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArgumentStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArgumentStatement.cs index 5c4b2a70f8..f8e88a2a48 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArgumentStatement.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArgumentStatement.cs @@ -29,7 +29,7 @@ public AssignArgumentStatement(ArgumentReference argument, IExpression expressio public void Emit(ILGenerator gen) { - ArgumentsUtil.EmitLoadOwnerAndReference(argument, gen); + argument.Emit(gen); expression.Emit(gen); } } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArrayStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArrayStatement.cs index b8ea4d599f..61e3c8b7e1 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArrayStatement.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArrayStatement.cs @@ -31,7 +31,7 @@ public AssignArrayStatement(Reference targetArray, int targetPosition, IExpressi public void Emit(ILGenerator il) { - ArgumentsUtil.EmitLoadOwnerAndReference(targetArray, il); + targetArray.Emit(il); il.Emit(OpCodes.Ldc_I4, targetPosition); diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IfNullExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IfNullExpression.cs index 333a732ac2..57f53bc374 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IfNullExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IfNullExpression.cs @@ -42,7 +42,7 @@ public void Emit(ILGenerator gen) { if (reference != null) { - ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen); + reference.Emit(gen); } else if (expression != null) { diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LoadRefArrayElementExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LoadRefArrayElementExpression.cs index 311a46c432..c1b5becb2b 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LoadRefArrayElementExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LoadRefArrayElementExpression.cs @@ -29,7 +29,7 @@ public LoadRefArrayElementExpression(int index, Reference arrayReference) public void Emit(ILGenerator gen) { - ArgumentsUtil.EmitLoadOwnerAndReference(arrayReference, gen); + arrayReference.Emit(gen); index.Emit(gen); gen.Emit(OpCodes.Ldelem_Ref); } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs index c0187029db..d646d19404 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs @@ -53,7 +53,8 @@ public virtual void Generate(ILGenerator gen) public void Emit(ILGenerator gen) { - ArgumentsUtil.EmitLoadOwnerAndReference(this, gen); + Owner?.Emit(gen); + LoadReference(gen); } } } \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs index e776d8b8db..93e8dcc81d 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs @@ -58,7 +58,7 @@ public void Emit(ILGenerator gen) } #endif - ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen); + reference.Emit(gen); if (reference.Type.IsByRef) { diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReturnStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReturnStatement.cs index 35bd01daf2..52f5176f6a 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReturnStatement.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReturnStatement.cs @@ -39,7 +39,7 @@ public void Emit(ILGenerator gen) { if (reference != null) { - ArgumentsUtil.EmitLoadOwnerAndReference(reference, gen); + reference.Emit(gen); } else if (expression != null) { From b1ec8cd466c444c4df2af002670347b7cb79a1f8 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 19:15:32 +0100 Subject: [PATCH 12/22] Move logic from `AssignStatement` into `Reference.StoreReference` --- .../Generators/Emitters/SimpleAST/ArgumentReference.cs | 5 ++++- .../Generators/Emitters/SimpleAST/AssignStatement.cs | 4 +--- .../Generators/Emitters/SimpleAST/ByRefReference.cs | 2 +- .../Generators/Emitters/SimpleAST/FieldReference.cs | 4 +++- .../Generators/Emitters/SimpleAST/IndirectReference.cs | 4 +++- .../Generators/Emitters/SimpleAST/LocalReference.cs | 4 +++- .../DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs | 2 +- 7 files changed, 16 insertions(+), 9 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs index 25e6bb02c4..49412d9168 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs @@ -66,12 +66,15 @@ public override void LoadReference(ILGenerator gen) } } - public override void StoreReference(ILGenerator gen) + public override void StoreReference(IExpression expression, ILGenerator gen) { if (Position == -1) { throw new InvalidOperationException("ArgumentReference uninitialized"); } + + Debug.Assert(owner == null); + expression.Emit(gen); gen.Emit(OpCodes.Starg, Position); } } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs index 947e8e876b..0fd1116908 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs @@ -29,9 +29,7 @@ public AssignStatement(Reference target, IExpression expression) public void Emit(ILGenerator gen) { - target.Owner?.Emit(gen); - expression.Emit(gen); - target.StoreReference(gen); + target.StoreReference(expression, gen); } } } \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs index 3e238f46f8..7a58f46aa7 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs @@ -40,7 +40,7 @@ public override void LoadReference(ILGenerator gen) localReference.LoadAddressOfReference(gen); } - public override void StoreReference(ILGenerator gen) + public override void StoreReference(IExpression expression, ILGenerator gen) { throw new NotImplementedException(); } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs index ab02547396..47ced1449d 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs @@ -82,8 +82,10 @@ public override void LoadReference(ILGenerator gen) } } - public override void StoreReference(ILGenerator gen) + public override void StoreReference(IExpression expression, ILGenerator gen) { + owner?.Emit(gen); + expression.Emit(gen); if (isStatic) { gen.Emit(OpCodes.Stsfld, Reference); diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs index 1e721c281c..15262cfd24 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs @@ -47,8 +47,10 @@ public override void LoadReference(ILGenerator gen) OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, Type); } - public override void StoreReference(ILGenerator gen) + public override void StoreReference(IExpression expression, ILGenerator gen) { + owner?.Emit(gen); + expression.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 index 2c7c902e4e..af66ca2afc 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs @@ -43,8 +43,10 @@ public override void LoadReference(ILGenerator gen) gen.Emit(OpCodes.Ldloc, localBuilder); } - public override void StoreReference(ILGenerator gen) + public override void StoreReference(IExpression expression, ILGenerator gen) { + Debug.Assert(owner == null); + expression.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 index d646d19404..b05544eda2 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs @@ -45,7 +45,7 @@ public Type Type public abstract void LoadReference(ILGenerator gen); - public abstract void StoreReference(ILGenerator gen); + public abstract void StoreReference(IExpression expression, ILGenerator gen); public virtual void Generate(ILGenerator gen) { From 8579344eac3d60c24ca2f7ebf11438caf0b92099 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 19:31:11 +0100 Subject: [PATCH 13/22] Move loading of `Reference.owner` into `LoadReference` --- .../Generators/Emitters/SimpleAST/ArgumentReference.cs | 1 + .../DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs | 1 + .../DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs | 1 + .../Generators/Emitters/SimpleAST/IndirectReference.cs | 1 + .../DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs | 1 + .../DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs | 1 - 6 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs index 49412d9168..478dc80fe2 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs @@ -42,6 +42,7 @@ public override void LoadAddressOfReference(ILGenerator gen) public override void LoadReference(ILGenerator gen) { + Owner?.Emit(gen); if (Position == -1) { throw new InvalidOperationException("ArgumentReference uninitialized"); diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs index 7a58f46aa7..c8f94e1ba0 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs @@ -37,6 +37,7 @@ public override void LoadAddressOfReference(ILGenerator gen) public override void LoadReference(ILGenerator gen) { + Owner?.Emit(gen); localReference.LoadAddressOfReference(gen); } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs index 47ced1449d..85f06ac19f 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs @@ -72,6 +72,7 @@ public override void LoadAddressOfReference(ILGenerator gen) public override void LoadReference(ILGenerator gen) { + Owner?.Emit(gen); if (isStatic) { gen.Emit(OpCodes.Ldsfld, Reference); diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs index 15262cfd24..03ca4cc44a 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs @@ -44,6 +44,7 @@ public override void LoadAddressOfReference(ILGenerator gen) public override void LoadReference(ILGenerator gen) { + Owner?.Emit(gen); OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, Type); } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs index af66ca2afc..f953b30d6a 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs @@ -40,6 +40,7 @@ public override void LoadAddressOfReference(ILGenerator gen) public override void LoadReference(ILGenerator gen) { + Owner?.Emit(gen); gen.Emit(OpCodes.Ldloc, localBuilder); } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs index b05544eda2..3057a3ab4b 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs @@ -53,7 +53,6 @@ public virtual void Generate(ILGenerator gen) public void Emit(ILGenerator gen) { - Owner?.Emit(gen); LoadReference(gen); } } From db7e83b78e2d0e23f5eafd55f87c7380264cdf3a Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 19:35:58 +0100 Subject: [PATCH 14/22] Not all `Reference`s have an owner --- .../Emitters/SimpleAST/ArgumentReference.cs | 6 ++---- .../Generators/Emitters/SimpleAST/ByRefReference.cs | 3 +-- .../Generators/Emitters/SimpleAST/FieldReference.cs | 10 +++++----- .../Emitters/SimpleAST/IndirectReference.cs | 12 ++++++++---- .../Generators/Emitters/SimpleAST/LocalReference.cs | 4 +--- .../Generators/Emitters/SimpleAST/Reference.cs | 10 +--------- 6 files changed, 18 insertions(+), 27 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs index 478dc80fe2..c1f911950e 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs @@ -22,13 +22,13 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST internal class ArgumentReference : Reference { public ArgumentReference(Type argumentType) - : base(null, argumentType) + : base(argumentType) { Position = -1; } public ArgumentReference(Type argumentType, int position) - : base(null, argumentType) + : base(argumentType) { Position = position; } @@ -42,7 +42,6 @@ public override void LoadAddressOfReference(ILGenerator gen) public override void LoadReference(ILGenerator gen) { - Owner?.Emit(gen); if (Position == -1) { throw new InvalidOperationException("ArgumentReference uninitialized"); @@ -74,7 +73,6 @@ public override void StoreReference(IExpression expression, ILGenerator gen) throw new InvalidOperationException("ArgumentReference uninitialized"); } - Debug.Assert(owner == null); expression.Emit(gen); gen.Emit(OpCodes.Starg, Position); } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs index c8f94e1ba0..c747896954 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs @@ -25,7 +25,7 @@ internal class ByRefReference : Reference private readonly LocalReference localReference; public ByRefReference(LocalReference localReference) - : base(null, localReference.Type) + : base(localReference.Type) { this.localReference = localReference; } @@ -37,7 +37,6 @@ public override void LoadAddressOfReference(ILGenerator gen) public override void LoadReference(ILGenerator gen) { - Owner?.Emit(gen); localReference.LoadAddressOfReference(gen); } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs index 85f06ac19f..be00321246 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs @@ -26,25 +26,23 @@ internal class FieldReference : Reference private readonly bool isStatic; public FieldReference(FieldInfo field) - : base(ThisExpression.Instance, field.FieldType) + : base(field.FieldType) { this.field = field; if ((field.Attributes & FieldAttributes.Static) != 0) { isStatic = true; - owner = null; } } public FieldReference(FieldBuilder fieldBuilder) - : base(ThisExpression.Instance, fieldBuilder.FieldType) + : base(fieldBuilder.FieldType) { this.fieldBuilder = fieldBuilder; field = fieldBuilder; if ((fieldBuilder.Attributes & FieldAttributes.Static) != 0) { isStatic = true; - owner = null; } } @@ -72,7 +70,8 @@ public override void LoadAddressOfReference(ILGenerator gen) public override void LoadReference(ILGenerator gen) { - Owner?.Emit(gen); + var owner = isStatic ? null : ThisExpression.Instance; + owner?.Emit(gen); if (isStatic) { gen.Emit(OpCodes.Ldsfld, Reference); @@ -85,6 +84,7 @@ public override void LoadReference(ILGenerator gen) public override void StoreReference(IExpression expression, ILGenerator gen) { + var owner = isStatic ? null : ThisExpression.Instance; owner?.Emit(gen); expression.Emit(gen); if (isStatic) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs index 03ca4cc44a..5e28eea050 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs @@ -23,16 +23,20 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST /// Wraps a reference that is passed /// ByRef and provides indirect load/store support. /// - [DebuggerDisplay("&{OwnerReference}")] + [DebuggerDisplay("&{owner}")] internal class IndirectReference : Reference { + private readonly Reference owner; + public IndirectReference(Reference byRefReference) : - base(byRefReference, byRefReference.Type.GetElementType()) + base(byRefReference.Type.GetElementType()) { if (!byRefReference.Type.IsByRef) { throw new ArgumentException("Expected an IsByRef reference", nameof(byRefReference)); } + + owner = byRefReference; } public override void LoadAddressOfReference(ILGenerator gen) @@ -44,13 +48,13 @@ public override void LoadAddressOfReference(ILGenerator gen) public override void LoadReference(ILGenerator gen) { - Owner?.Emit(gen); + owner.Emit(gen); OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, Type); } public override void StoreReference(IExpression expression, ILGenerator gen) { - owner?.Emit(gen); + owner.Emit(gen); expression.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 index f953b30d6a..e4db3733d3 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs @@ -24,7 +24,7 @@ internal class LocalReference : Reference private LocalBuilder localBuilder; public LocalReference(Type type) - : base(null, type) + : base(type) { } @@ -40,13 +40,11 @@ public override void LoadAddressOfReference(ILGenerator gen) public override void LoadReference(ILGenerator gen) { - Owner?.Emit(gen); gen.Emit(OpCodes.Ldloc, localBuilder); } public override void StoreReference(IExpression expression, ILGenerator gen) { - Debug.Assert(owner == null); expression.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 index 3057a3ab4b..57cb61933b 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs @@ -21,21 +21,13 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST internal abstract class Reference : IExpression { - protected IExpression? owner; protected readonly Type type; - protected Reference(IExpression? owner, Type type) + protected Reference(Type type) { - this.owner = owner; this.type = type; } - public IExpression? Owner - { - get { return owner; } - set { owner = value; } - } - public Type Type { get { return type; } From a0dc3123bc3caa610589111ccd8852c7b0729bcb Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 19:45:03 +0100 Subject: [PATCH 15/22] Decouple `AssignArgumentStatement` and `DefaultValueExpression` --- .../SimpleAST/AssignArgumentStatement.cs | 36 ------------------- .../SimpleAST/DefaultValueExpression.cs | 22 ------------ .../Generators/MinimalisticMethodGenerator.cs | 6 ++-- .../OptionallyForwardingMethodGenerator.cs | 6 ++-- 4 files changed, 8 insertions(+), 62 deletions(-) delete mode 100644 src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArgumentStatement.cs diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArgumentStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArgumentStatement.cs deleted file mode 100644 index f8e88a2a48..0000000000 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArgumentStatement.cs +++ /dev/null @@ -1,36 +0,0 @@ -// Copyright 2004-2021 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.Reflection.Emit; - - internal class AssignArgumentStatement : IStatement - { - private readonly ArgumentReference argument; - private readonly IExpression expression; - - public AssignArgumentStatement(ArgumentReference argument, IExpression expression) - { - this.argument = argument; - this.expression = expression; - } - - public void Emit(ILGenerator gen) - { - argument.Emit(gen); - expression.Emit(gen); - } - } -} \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/DefaultValueExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/DefaultValueExpression.cs index c4668cf208..fe2d3c66a3 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/DefaultValueExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/DefaultValueExpression.cs @@ -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/MinimalisticMethodGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/MinimalisticMethodGenerator.cs index 965ea8e78e..7b7ce3511c 100644 --- a/src/Castle.Core/DynamicProxy/Generators/MinimalisticMethodGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/MinimalisticMethodGenerator.cs @@ -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 index 6f8dc480fe..66313ea9dd 100644 --- 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()))); } } } From 2dcb49b9e8dff832e7aaf114a6c95ba095cd3466 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 20:17:28 +0100 Subject: [PATCH 16/22] Split up `AssignArrayStatement` --- .../Contributors/SerializableContributor.cs | 5 +- .../Generators/BaseProxyGenerator.cs | 4 +- .../SimpleAST/ArrayElementReference.cs | 81 +++++++++++++++++++ .../SimpleAST/AssignArrayStatement.cs | 43 ---------- .../SimpleAST/LiteralIntExpression.cs | 4 +- .../MethodWithInvocationGenerator.cs | 4 +- 6 files changed, 92 insertions(+), 49 deletions(-) create mode 100644 src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArrayElementReference.cs delete mode 100644 src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArrayStatement.cs diff --git a/src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs index c4ff33945c..86ea8d332f 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs @@ -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))); } diff --git a/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs index 2d790409d6..bb50da6e31 100644 --- a/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs @@ -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 diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArrayElementReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArrayElementReference.cs new file mode 100644 index 0000000000..a07ef9aaca --- /dev/null +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArrayElementReference.cs @@ -0,0 +1,81 @@ +// 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. + +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); + Debug.Assert(array.Type.GetElementType().IsClass || array.Type.GetElementType().IsInterface); + + this.array = array; + this.index = index; + } + + public override void LoadAddressOfReference(ILGenerator gen) + { + array.Emit(gen); + LiteralIntExpression.Emit(index, gen); + gen.Emit(OpCodes.Ldelema); + } + + public override void LoadReference(ILGenerator gen) + { + array.Emit(gen); + LiteralIntExpression.Emit(index, gen); + gen.Emit(OpCodes.Ldelem_Ref); + + // NOTE: The opcode isedabove is only valid for reference types. + // Here's the opcode mapping for all array element types: + // + // | element type | opcode + // |----------------------------------------------|------------------- + // | signed primitive types and enums | ldelem.i{1,2,4,8} + // | unsigned primitive types (including `bool`) | ldelem.u{1,2,4} + // | `nint` and `nuint` | ldelem.i + // | floating point primitive types | ldelem.r{4,8} + // | generic type param/args and structs | ldelem + // | classes and interfaces | ldelem.ref + } + + public override void StoreReference(IExpression expression, ILGenerator gen) + { + array.Emit(gen); + LiteralIntExpression.Emit(index, gen); + expression.Emit(gen); + gen.Emit(OpCodes.Stelem_Ref); + + // NOTE: The opcode used above is only valid for reference types. + // Here's the opcode mapping for all array element types: + // + // | element type | opcode + // |----------------------------------------------|------------------- + // | signed primitive types and enums | stelem.i{1,2,4,8} + // | unsigned primitive types (including `bool`) | stelem.u{1,2,4} + // | `nint` and `nuint` | stelem.i + // | floating point primitive types | stelem.r{4,8} + // | generic type param/args and structs | stelem + // | classes and interfaces | stelem.ref + } + } +} diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArrayStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArrayStatement.cs deleted file mode 100644 index 61e3c8b7e1..0000000000 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignArrayStatement.cs +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright 2004-2021 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.Reflection.Emit; - - internal class AssignArrayStatement : IStatement - { - private readonly Reference targetArray; - private readonly int targetPosition; - private readonly IExpression value; - - public AssignArrayStatement(Reference targetArray, int targetPosition, IExpression value) - { - this.targetArray = targetArray; - this.targetPosition = targetPosition; - this.value = value; - } - - public void Emit(ILGenerator il) - { - targetArray.Emit(il); - - il.Emit(OpCodes.Ldc_I4, targetPosition); - - value.Emit(il); - - il.Emit(OpCodes.Stelem_Ref); - } - } -} \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LiteralIntExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LiteralIntExpression.cs index 3e07dd435c..15a4f9a9a5 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LiteralIntExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LiteralIntExpression.cs @@ -25,7 +25,9 @@ public LiteralIntExpression(int value) this.value = value; } - public void Emit(ILGenerator gen) + public void Emit(ILGenerator gen) => Emit(value, gen); + + internal static void Emit(int value, ILGenerator gen) { switch (value) { diff --git a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs index 36313d68d5..eeb3130aa7 100644 --- a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.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, From 4fa838d49a4911d88d6a74f19e31476fb52e05f1 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Sun, 14 Dec 2025 20:40:47 +0100 Subject: [PATCH 17/22] Downgrade `ByRefReference` to an expression & rename it --- .../{ByRefReference.cs => ByRefExpression.cs} | 27 +++++-------------- .../Generators/InvocationTypeGenerator.cs | 2 +- 2 files changed, 8 insertions(+), 21 deletions(-) rename src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/{ByRefReference.cs => ByRefExpression.cs} (55%) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefExpression.cs similarity index 55% rename from src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs rename to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefExpression.cs index c747896954..e63a775ff3 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefExpression.cs @@ -14,35 +14,22 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST { - using System; using System.Diagnostics; using System.Reflection.Emit; - - [DebuggerDisplay("&{localReference}")] - internal class ByRefReference : Reference + [DebuggerDisplay("&{reference}")] + internal class ByRefExpression : IExpression { - private readonly LocalReference localReference; - - public ByRefReference(LocalReference localReference) - : base(localReference.Type) - { - this.localReference = localReference; - } - - public override void LoadAddressOfReference(ILGenerator gen) - { - localReference.LoadAddressOfReference(gen); - } + private readonly Reference reference; - public override void LoadReference(ILGenerator gen) + public ByRefExpression(Reference reference) { - localReference.LoadAddressOfReference(gen); + this.reference = reference; } - public override void StoreReference(IExpression expression, ILGenerator gen) + public void Emit(ILGenerator gen) { - throw new NotImplementedException(); + reference.LoadAddressOfReference(gen); } } } \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs index 299ca35fc4..dd91c22fa2 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs @@ -149,7 +149,7 @@ protected virtual void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocat } invokeMethodOnTarget.CodeBuilder.AddStatement(new AssignStatement(localReference, localValue)); - var byRefReference = new ByRefReference(localReference); + var byRefReference = new ByRefExpression(localReference); args[i] = byRefReference; byRefArguments[i] = localReference; } From 6686011829f391560ae0f8f7c91db38490cfcf8c Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Mon, 15 Dec 2025 00:57:22 +0100 Subject: [PATCH 18/22] Merge identical code paths for expressions and references --- .../Emitters/SimpleAST/IfNullExpression.cs | 18 +-------------- .../Emitters/SimpleAST/ReturnStatement.cs | 22 ++++--------------- 2 files changed, 5 insertions(+), 35 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IfNullExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IfNullExpression.cs index 57f53bc374..f7d206c20f 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IfNullExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IfNullExpression.cs @@ -21,16 +21,8 @@ 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; - } - public IfNullExpression(IExpression expression, IExpressionOrStatement ifNull, IExpressionOrStatement ifNotNull = null) { this.expression = expression ?? throw new ArgumentNullException(nameof(expression)); @@ -40,15 +32,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/ReturnStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReturnStatement.cs index 52f5176f6a..55ad034d23 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReturnStatement.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReturnStatement.cs @@ -18,34 +18,20 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST internal class ReturnStatement : IStatement { - private readonly IExpression expression; - private readonly Reference reference; + private readonly IExpression value; public ReturnStatement() { } - public ReturnStatement(Reference reference) + public ReturnStatement(IExpression value) { - this.reference = reference; - } - - public ReturnStatement(IExpression expression) - { - this.expression = expression; + this.value = value; } public void Emit(ILGenerator gen) { - if (reference != null) - { - reference.Emit(gen); - } - else if (expression != null) - { - expression.Emit(gen); - } - + value?.Emit(gen); gen.Emit(OpCodes.Ret); } } From cf0b632474e65e7258847043e624c6aa9ca9aebf Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Mon, 15 Dec 2025 01:12:17 +0100 Subject: [PATCH 19/22] `LoadRefArrayElementExpression` has been superseded --- .../LoadRefArrayElementExpression.cs | 37 ------------------- .../DynamicProxy/Generators/GeneratorUtil.cs | 2 +- 2 files changed, 1 insertion(+), 38 deletions(-) delete mode 100644 src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LoadRefArrayElementExpression.cs diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LoadRefArrayElementExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LoadRefArrayElementExpression.cs deleted file mode 100644 index c1b5becb2b..0000000000 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LoadRefArrayElementExpression.cs +++ /dev/null @@ -1,37 +0,0 @@ -// Copyright 2004-2021 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.Reflection.Emit; - - internal class LoadRefArrayElementExpression : IExpression - { - private readonly Reference arrayReference; - private readonly LiteralIntExpression index; - - public LoadRefArrayElementExpression(int index, Reference arrayReference) - { - this.index = new LiteralIntExpression(index); - this.arrayReference = arrayReference; - } - - public void Emit(ILGenerator gen) - { - arrayReference.Emit(gen); - index.Emit(gen); - gen.Emit(OpCodes.Ldelem_Ref); - } - } -} \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.cs b/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.cs index d711af5934..6a01b29e6b 100644 --- a/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.cs +++ b/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.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, From c3d65f8aca806bba00c8b1062aa7d183adf2ec43 Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Mon, 15 Dec 2025 01:15:54 +0100 Subject: [PATCH 20/22] Rename `ReferencesToObjectArrayExpression` --- ...cs => ArgumentsToObjectArrayExpression.cs} | 21 +++++++++---------- .../MethodWithInvocationGenerator.cs | 2 +- 2 files changed, 11 insertions(+), 12 deletions(-) rename src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/{ReferencesToObjectArrayExpression.cs => ArgumentsToObjectArrayExpression.cs} (78%) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentsToObjectArrayExpression.cs similarity index 78% rename from src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs rename to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentsToObjectArrayExpression.cs index 93e8dcc81d..ee08550e77 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferencesToObjectArrayExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentsToObjectArrayExpression.cs @@ -15,16 +15,15 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST { using System; - using System.Reflection; using System.Reflection.Emit; using Castle.DynamicProxy.Internal; - internal class ReferencesToObjectArrayExpression : IExpression + internal sealed class ArgumentsToObjectArrayExpression : IExpression { private readonly Reference[] args; - public ReferencesToObjectArrayExpression(params Reference[] args) + public ArgumentsToObjectArrayExpression(params Reference[] args) { this.args = args; } @@ -42,10 +41,10 @@ public void Emit(ILGenerator gen) gen.Emit(OpCodes.Ldloc, local); gen.Emit(OpCodes.Ldc_I4, i); - var reference = args[i]; + var arg = args[i]; #if FEATURE_BYREFLIKE - if (reference.Type.IsByRefLikeSafe()) + if (arg.Type.IsByRefLikeSafe()) { // The by-ref-like argument value cannot be put into the `object[]` array, // because it cannot be boxed. We need to replace it with some other value. @@ -58,20 +57,20 @@ public void Emit(ILGenerator gen) } #endif - reference.Emit(gen); + arg.Emit(gen); - if (reference.Type.IsByRef) + if (arg.Type.IsByRef) { throw new NotSupportedException(); } - if (reference.Type.IsValueType) + if (arg.Type.IsValueType) { - gen.Emit(OpCodes.Box, reference.Type); + gen.Emit(OpCodes.Box, arg.Type); } - else if (reference.Type.IsGenericParameter) + else if (arg.Type.IsGenericParameter) { - gen.Emit(OpCodes.Box, reference.Type); + gen.Emit(OpCodes.Box, arg.Type); } gen.Emit(OpCodes.Stelem_Ref); diff --git a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs index eeb3130aa7..5bb871ad47 100644 --- a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs @@ -240,7 +240,7 @@ private IExpression[] GetCtorArguments(ClassEmitter @class, IExpression proxiedM ThisExpression.Instance, methodInterceptors ?? interceptors, proxiedMethodTokenExpression, - new ReferencesToObjectArrayExpression(dereferencedArguments) + new ArgumentsToObjectArrayExpression(dereferencedArguments) }; } From ba565d968c042a0d20b29db9ad552dd46e25828e Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Mon, 15 Dec 2025 01:22:09 +0100 Subject: [PATCH 21/22] Finetune a few `[DebuggerDisplay]`s --- .../Generators/Emitters/SimpleAST/FieldReference.cs | 2 +- .../Generators/Emitters/SimpleAST/IndirectReference.cs | 2 +- .../Emitters/SimpleAST/NullCoalescingOperatorExpression.cs | 2 ++ .../Generators/Emitters/SimpleAST/TypeTokenExpression.cs | 2 ++ 4 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs index be00321246..e2d468bec2 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs @@ -18,7 +18,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/IndirectReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs index 5e28eea050..17185d20b5 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs @@ -23,7 +23,7 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST /// Wraps a reference that is passed /// ByRef and provides indirect load/store support. /// - [DebuggerDisplay("&{owner}")] + [DebuggerDisplay("*{owner}")] internal class IndirectReference : Reference { private readonly Reference owner; diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/NullCoalescingOperatorExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/NullCoalescingOperatorExpression.cs index 7c492a6ae8..c1cb306ad9 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/NullCoalescingOperatorExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/NullCoalescingOperatorExpression.cs @@ -15,8 +15,10 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST { using System; + using System.Diagnostics; using System.Reflection.Emit; + [DebuggerDisplay("{expression} ?? {default}")] internal class NullCoalescingOperatorExpression : IExpression { private readonly IExpression @default; diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeTokenExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeTokenExpression.cs index 2a390c286c..287448f4ad 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeTokenExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/TypeTokenExpression.cs @@ -15,10 +15,12 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST { using System; + using System.Diagnostics; using System.Reflection.Emit; using Castle.DynamicProxy.Tokens; + [DebuggerDisplay("typeof {type}")] internal class TypeTokenExpression : IExpression { private readonly Type type; From 56bee54e04c7b15157d68a6acd760853e8a5ec8f Mon Sep 17 00:00:00 2001 From: Dominique Schuppli Date: Mon, 15 Dec 2025 01:53:11 +0100 Subject: [PATCH 22/22] Rename all `Reference`s to `Location`s --- .../ClassProxySerializableContributor.cs | 20 +++++++------- .../ClassProxyTargetContributor.cs | 2 +- .../ClassProxyWithTargetTargetContributor.cs | 2 +- .../IInvocationCreationContributor.cs | 4 +-- .../InterfaceProxySerializableContributor.cs | 4 +-- .../InvocationWithDelegateContributor.cs | 16 +++++------ ...nvocationWithGenericDelegateContributor.cs | 8 +++--- .../Contributors/MixinContributor.cs | 6 ++--- .../ProxyTargetAccessorContributor.cs | 2 +- .../Contributors/SerializableContributor.cs | 10 +++---- .../Generators/BaseClassProxyGenerator.cs | 4 +-- .../Generators/BaseInterfaceProxyGenerator.cs | 8 +++--- .../Generators/BaseProxyGenerator.cs | 22 +++++++-------- .../Generators/ClassProxyGenerator.cs | 2 +- .../ClassProxyWithTargetGenerator.cs | 4 +-- .../CompositionInvocationTypeGenerator.cs | 18 ++++++------- .../Generators/DelegateTypeGenerator.cs | 4 +-- .../Emitters/AbstractTypeEmitter.cs | 26 +++++++++--------- .../Generators/Emitters/ArgumentsUtil.cs | 18 ++++++------- .../Generators/Emitters/CodeBuilder.cs | 8 +++--- .../Generators/Emitters/ConstructorEmitter.cs | 2 +- .../Generators/Emitters/MethodEmitter.cs | 4 +-- ...gumentReference.cs => ArgumentLocation.cs} | 16 +++++------ .../ArgumentsToObjectArrayExpression.cs | 4 +-- ...ntReference.cs => ArrayElementLocation.cs} | 12 ++++----- .../Emitters/SimpleAST/AssignStatement.cs | 6 ++--- .../Emitters/SimpleAST/ByRefExpression.cs | 8 +++--- .../{FieldReference.cs => FieldLocation.cs} | 12 ++++----- ...directReference.cs => IndirectLocation.cs} | 20 +++++++------- .../{LocalReference.cs => LocalLocation.cs} | 10 +++---- .../SimpleAST/{Reference.cs => Location.cs} | 27 ++++++++++++++----- .../DynamicProxy/Generators/GeneratorUtil.cs | 16 +++++------ .../InheritanceInvocationTypeGenerator.cs | 16 +++++------ .../Generators/InvocationTypeGenerator.cs | 24 ++++++++--------- .../MethodWithInvocationGenerator.cs | 14 +++++----- .../Generators/MinimalisticMethodGenerator.cs | 4 +-- .../OptionallyForwardingMethodGenerator.cs | 4 +-- 37 files changed, 201 insertions(+), 186 deletions(-) rename src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/{ArgumentReference.cs => ArgumentLocation.cs} (79%) rename src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/{ArrayElementReference.cs => ArrayElementLocation.cs} (88%) rename src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/{FieldReference.cs => FieldLocation.cs} (86%) rename src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/{IndirectReference.cs => IndirectLocation.cs} (73%) rename src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/{LocalReference.cs => LocalLocation.cs} (80%) rename src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/{Reference.cs => Location.cs} (51%) diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs index 87daeda950..011a115565 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs @@ -33,7 +33,7 @@ internal class ClassProxySerializableContributor : SerializableContributor { private bool delegateToBaseGetObjectData; private ConstructorInfo serializationConstructor; - private readonly IList serializedFields = new List(); + private readonly IList serializedFields = new List(); public ClassProxySerializableContributor(Type targetType, Type[] interfaces, string typeId) : base(targetType, interfaces, typeId) @@ -82,15 +82,15 @@ public override void Generate(ClassEmitter @class) Constructor(@class); } - protected override void AddAddValueInvocation(ArgumentReference serializationInfo, MethodEmitter getObjectData, - FieldReference field) + protected override void AddAddValueInvocation(ArgumentLocation serializationInfo, MethodEmitter getObjectData, + FieldLocation field) { serializedFields.Add(field); base.AddAddValueInvocation(serializationInfo, getObjectData, field); } - protected override void CustomizeGetObjectData(CodeBuilder codeBuilder, ArgumentReference serializationInfo, - ArgumentReference streamingContext, ClassEmitter emitter) + protected override void CustomizeGetObjectData(CodeBuilder codeBuilder, ArgumentLocation serializationInfo, + ArgumentLocation streamingContext, ClassEmitter emitter) { codeBuilder.AddStatement( new MethodInvocationExpression( @@ -108,7 +108,7 @@ protected override void CustomizeGetObjectData(CodeBuilder codeBuilder, Argument EmitCallToBaseGetObjectData(codeBuilder, serializationInfo, streamingContext); } - private void EmitCustomGetObjectData(CodeBuilder codeBuilder, ArgumentReference serializationInfo) + private void EmitCustomGetObjectData(CodeBuilder codeBuilder, ArgumentLocation serializationInfo) { var members = codeBuilder.DeclareLocal(typeof(MemberInfo[])); var data = codeBuilder.DeclareLocal(typeof(object[])); @@ -141,8 +141,8 @@ private void EmitCustomGetObjectData(CodeBuilder codeBuilder, ArgumentReference codeBuilder.AddStatement(addValue); } - private void EmitCallToBaseGetObjectData(CodeBuilder codeBuilder, ArgumentReference serializationInfo, - ArgumentReference streamingContext) + private void EmitCallToBaseGetObjectData(CodeBuilder codeBuilder, ArgumentLocation serializationInfo, + ArgumentLocation streamingContext) { var baseGetObjectData = targetType.GetMethod("GetObjectData", new[] { typeof(SerializationInfo), typeof(StreamingContext) }); @@ -166,8 +166,8 @@ private void Constructor(ClassEmitter emitter) private void GenerateSerializationConstructor(ClassEmitter emitter) { - var serializationInfo = new ArgumentReference(typeof(SerializationInfo)); - var streamingContext = new ArgumentReference(typeof(StreamingContext)); + var serializationInfo = new ArgumentLocation(typeof(SerializationInfo)); + var streamingContext = new ArgumentLocation(typeof(StreamingContext)); var ctor = emitter.CreateConstructor(serializationInfo, streamingContext); diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs index d865eebe92..cd3142dba5 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs @@ -158,7 +158,7 @@ private IInvocationCreationContributor GetContributor(Type @delegate, MetaMethod } return new InvocationWithGenericDelegateContributor(@delegate, method, - new FieldReference(InvocationMethods.ProxyObject)); + new FieldLocation(InvocationMethods.ProxyObject)); } private Type GetDelegateType(MetaMethod method, ClassEmitter @class) diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyWithTargetTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyWithTargetTargetContributor.cs index d834373c3b..8e0acbc9ab 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyWithTargetTargetContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyWithTargetTargetContributor.cs @@ -109,7 +109,7 @@ private IInvocationCreationContributor GetContributor(Type @delegate, MetaMethod } return new InvocationWithGenericDelegateContributor(@delegate, method, - new FieldReference(InvocationMethods.CompositionInvocationTarget)); + new FieldLocation(InvocationMethods.CompositionInvocationTarget)); } private Type GetDelegateType(MetaMethod method, ClassEmitter @class) diff --git a/src/Castle.Core/DynamicProxy/Contributors/IInvocationCreationContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/IInvocationCreationContributor.cs index 87b94f848b..2c1be5bdd6 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/IInvocationCreationContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/IInvocationCreationContributor.cs @@ -21,12 +21,12 @@ namespace Castle.DynamicProxy.Contributors internal interface IInvocationCreationContributor { - ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation); + ConstructorEmitter CreateConstructor(ArgumentLocation[] baseCtorArguments, AbstractTypeEmitter invocation); MethodInfo GetCallbackMethod(); MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, IExpression[] args, - Reference targetField, MethodEmitter invokeMethodOnTarget); + Location targetField, MethodEmitter invokeMethodOnTarget); IExpression[] GetConstructorInvocationArguments(IExpression[] arguments, ClassEmitter proxy); } diff --git a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxySerializableContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxySerializableContributor.cs index a9b85d86ea..cc11fd4231 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxySerializableContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxySerializableContributor.cs @@ -29,8 +29,8 @@ public InterfaceProxySerializableContributor(Type targetType, string proxyGenera { } - protected override void CustomizeGetObjectData(CodeBuilder codeBuilder, ArgumentReference serializationInfo, - ArgumentReference streamingContext, ClassEmitter emitter) + protected override void CustomizeGetObjectData(CodeBuilder codeBuilder, ArgumentLocation serializationInfo, + ArgumentLocation streamingContext, ClassEmitter emitter) { var targetField = emitter.GetField("__target"); diff --git a/src/Castle.Core/DynamicProxy/Contributors/InvocationWithDelegateContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InvocationWithDelegateContributor.cs index 48f7d29691..74cf85c273 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/InvocationWithDelegateContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/InvocationWithDelegateContributor.cs @@ -40,7 +40,7 @@ public InvocationWithDelegateContributor(Type delegateType, Type targetType, Met this.namingScope = namingScope; } - public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation) + public ConstructorEmitter CreateConstructor(ArgumentLocation[] baseCtorArguments, AbstractTypeEmitter invocation) { var arguments = GetArguments(baseCtorArguments); var constructor = invocation.CreateConstructor(arguments); @@ -56,11 +56,11 @@ public MethodInfo GetCallbackMethod() } public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, IExpression[] args, - Reference targetField, + Location targetField, MethodEmitter invokeMethodOnTarget) { var allArgs = GetAllArgs(args, targetField); - var @delegate = (Reference)invocation.GetField("delegate"); + var @delegate = (Location)invocation.GetField("delegate"); return new MethodInvocationExpression(@delegate, GetCallbackMethod(), allArgs); } @@ -73,7 +73,7 @@ public IExpression[] GetConstructorInvocationArguments(IExpression[] arguments, return allArguments; } - private FieldReference BuildDelegateToken(ClassEmitter proxy) + private FieldLocation BuildDelegateToken(ClassEmitter proxy) { var callback = proxy.CreateStaticField(namingScope.GetUniqueName("callback_" + method.Method.Name), delegateType); var createDelegate = new MethodInvocationExpression( @@ -88,7 +88,7 @@ private FieldReference BuildDelegateToken(ClassEmitter proxy) return callback; } - private IExpression[] GetAllArgs(IExpression[] args, Reference targetField) + private IExpression[] GetAllArgs(IExpression[] args, Location targetField) { var allArgs = new IExpression[args.Length + 1]; args.CopyTo(allArgs, 1); @@ -96,10 +96,10 @@ private IExpression[] GetAllArgs(IExpression[] args, Reference targetField) return allArgs; } - private ArgumentReference[] GetArguments(ArgumentReference[] baseCtorArguments) + private ArgumentLocation[] GetArguments(ArgumentLocation[] baseCtorArguments) { - var arguments = new ArgumentReference[baseCtorArguments.Length + 1]; - arguments[0] = new ArgumentReference(delegateType); + var arguments = new ArgumentLocation[baseCtorArguments.Length + 1]; + arguments[0] = new ArgumentLocation(delegateType); baseCtorArguments.CopyTo(arguments, 1); return arguments; } diff --git a/src/Castle.Core/DynamicProxy/Contributors/InvocationWithGenericDelegateContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InvocationWithGenericDelegateContributor.cs index f5b596d1d2..a37b1b4550 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/InvocationWithGenericDelegateContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/InvocationWithGenericDelegateContributor.cs @@ -39,7 +39,7 @@ public InvocationWithGenericDelegateContributor(Type delegateType, MetaMethod me this.target = target; } - public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation) + public ConstructorEmitter CreateConstructor(ArgumentLocation[] baseCtorArguments, AbstractTypeEmitter invocation) { return invocation.CreateConstructor(baseCtorArguments); } @@ -50,7 +50,7 @@ public MethodInfo GetCallbackMethod() } public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, IExpression[] args, - Reference targetField, + Location targetField, MethodEmitter invokeMethodOnTarget) { var @delegate = GetDelegate(invocation, invokeMethodOnTarget); @@ -62,7 +62,7 @@ public IExpression[] GetConstructorInvocationArguments(IExpression[] arguments, return arguments; } - private Reference GetDelegate(AbstractTypeEmitter invocation, MethodEmitter invokeMethodOnTarget) + private Location GetDelegate(AbstractTypeEmitter invocation, MethodEmitter invokeMethodOnTarget) { var genericTypeParameters = invocation.GenericTypeParams.AsTypeArray(); var closedDelegateType = delegateType.MakeGenericType(genericTypeParameters); @@ -73,7 +73,7 @@ private Reference GetDelegate(AbstractTypeEmitter invocation, MethodEmitter invo return localReference; } - private AssignStatement SetDelegate(LocalReference localDelegate, IExpression target, + private AssignStatement SetDelegate(LocalLocation localDelegate, IExpression target, Type closedDelegateType, MethodInfo closedMethodOnTarget) { var delegateCreateDelegate = new MethodInvocationExpression( diff --git a/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs index e633b47348..8d1c251fdb 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/MixinContributor.cs @@ -28,7 +28,7 @@ internal class MixinContributor : CompositeTypeContributor { private readonly bool canChangeTarget; private readonly IList empty = new List(); - private readonly IDictionary fields = new SortedDictionary(new FieldReferenceComparer()); + private readonly IDictionary fields = new SortedDictionary(new FieldReferenceComparer()); private readonly GetTargetExpressionDelegate getTarget; public MixinContributor(INamingScope namingScope, bool canChangeTarget) @@ -38,7 +38,7 @@ public MixinContributor(INamingScope namingScope, bool canChangeTarget) getTarget = BuildGetTargetExpression(); } - public IEnumerable Fields + public IEnumerable Fields { get { return fields.Values; } } @@ -118,7 +118,7 @@ private GetTargetExpressionDelegate BuildGetTargetExpression() fields[m.DeclaringType]); } - private FieldReference BuildTargetField(ClassEmitter @class, Type type) + private FieldLocation BuildTargetField(ClassEmitter @class, Type type) { var name = "__mixin_" + type.FullName.Replace(".", "_"); return @class.CreateField(namingScope.GetUniqueName(name), type); diff --git a/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs index 963ab3bf76..45a28fdea9 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs @@ -51,7 +51,7 @@ public void Generate(ClassEmitter emitter) var dynProxySetTarget = emitter.CreateMethod(nameof(IProxyTargetAccessor.DynProxySetTarget), typeof(void), typeof(object)); // we can only change the target of the interface proxy - if (target is FieldReference targetField) + if (target is FieldLocation targetField) { dynProxySetTarget.CodeBuilder.AddStatement( new AssignStatement(targetField, diff --git a/src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs index 86ea8d332f..9acf3bffb4 100644 --- a/src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs +++ b/src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs @@ -91,7 +91,7 @@ protected void ImplementGetObjectData(ClassEmitter emitter) { getObjectData.CodeBuilder.AddStatement( new AssignStatement( - new ArrayElementReference(interfacesLocal, i), + new ArrayElementLocation(interfacesLocal, i), new LiteralStringExpression(interfaces[i].AssemblyQualifiedName))); } @@ -128,8 +128,8 @@ protected void ImplementGetObjectData(ClassEmitter emitter) getObjectData.CodeBuilder.AddStatement(new ReturnStatement()); } - protected virtual void AddAddValueInvocation(ArgumentReference serializationInfo, MethodEmitter getObjectData, - FieldReference field) + protected virtual void AddAddValueInvocation(ArgumentLocation serializationInfo, MethodEmitter getObjectData, + FieldLocation field) { getObjectData.CodeBuilder.AddStatement( new MethodInvocationExpression( @@ -140,8 +140,8 @@ protected virtual void AddAddValueInvocation(ArgumentReference serializationInfo return; } - protected abstract void CustomizeGetObjectData(CodeBuilder builder, ArgumentReference serializationInfo, - ArgumentReference streamingContext, ClassEmitter emitter); + protected abstract void CustomizeGetObjectData(CodeBuilder builder, ArgumentLocation serializationInfo, + ArgumentLocation streamingContext, ClassEmitter emitter); public virtual void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model) { diff --git a/src/Castle.Core/DynamicProxy/Generators/BaseClassProxyGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/BaseClassProxyGenerator.cs index 02f6012380..794b34a165 100644 --- a/src/Castle.Core/DynamicProxy/Generators/BaseClassProxyGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/BaseClassProxyGenerator.cs @@ -31,7 +31,7 @@ protected BaseClassProxyGenerator(ModuleScope scope, Type targetType, Type[] int EnsureDoesNotImplementIProxyTargetAccessor(targetType, nameof(targetType)); } - protected abstract FieldReference TargetField { get; } + protected abstract FieldLocation TargetField { get; } #if FEATURE_SERIALIZATION protected abstract SerializableContributor GetSerializableContributor(); @@ -62,7 +62,7 @@ protected sealed override Type GenerateType(string name, INamingScope namingScop // Constructor var cctor = GenerateStaticConstructor(emitter); - var constructorArguments = new List(); + var constructorArguments = new List(); if (TargetField is { } targetField) { diff --git a/src/Castle.Core/DynamicProxy/Generators/BaseInterfaceProxyGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/BaseInterfaceProxyGenerator.cs index 84e6b1186b..45a25589e8 100644 --- a/src/Castle.Core/DynamicProxy/Generators/BaseInterfaceProxyGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/BaseInterfaceProxyGenerator.cs @@ -31,7 +31,7 @@ internal abstract class BaseInterfaceProxyGenerator : BaseProxyGenerator { protected readonly Type proxyTargetType; - protected FieldReference targetField; + protected FieldLocation targetField; protected BaseInterfaceProxyGenerator(ModuleScope scope, Type targetType, Type[] interfaces, Type proxyTargetType, ProxyGenerationOptions options) @@ -99,13 +99,13 @@ protected override Type GenerateType(string typeName, INamingScope namingScope) ProxyGenerationOptions.Hook.MethodsInspected(); ClassEmitter emitter; - FieldReference interceptorsField; + FieldLocation interceptorsField; var baseType = Init(typeName, out emitter, proxyTargetType, out interceptorsField, allInterfaces); // Constructor var cctor = GenerateStaticConstructor(emitter); - var ctorArguments = new List(); + var ctorArguments = new List(); foreach (var contributor in contributors) { @@ -237,7 +237,7 @@ protected virtual IEnumerable GetTypeImplementerMapping(Type proxyTargetTy } protected virtual Type Init(string typeName, out ClassEmitter emitter, Type proxyTargetType, - out FieldReference interceptorsField, IEnumerable allInterfaces) + out FieldLocation interceptorsField, IEnumerable allInterfaces) { var baseType = ProxyGenerationOptions.BaseTypeForInterfaceProxy; diff --git a/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs index bb50da6e31..22afe73ee7 100644 --- a/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs @@ -175,7 +175,7 @@ protected void CreateInterceptorsField(ClassEmitter emitter) #endif } - protected FieldReference CreateOptionsField(ClassEmitter emitter) + protected FieldLocation CreateOptionsField(ClassEmitter emitter) { return emitter.CreateStaticField("proxyGenerationOptions", typeof(ProxyGenerationOptions)); } @@ -215,9 +215,9 @@ protected void EnsureOptionsOverrideEqualsAndGetHashCode() } protected void GenerateConstructor(ClassEmitter emitter, ConstructorInfo baseConstructor, - params FieldReference[] fields) + params FieldLocation[] fields) { - ArgumentReference[] args; + ArgumentLocation[] args; ParameterInfo[] baseConstructorParams = null; if (baseConstructor != null) @@ -227,23 +227,23 @@ protected void GenerateConstructor(ClassEmitter emitter, ConstructorInfo baseCon if (baseConstructorParams != null && baseConstructorParams.Length != 0) { - args = new ArgumentReference[fields.Length + baseConstructorParams.Length]; + args = new ArgumentLocation[fields.Length + baseConstructorParams.Length]; var offset = fields.Length; for (var i = offset; i < offset + baseConstructorParams.Length; i++) { var paramInfo = baseConstructorParams[i - offset]; - args[i] = new ArgumentReference(paramInfo.ParameterType); + args[i] = new ArgumentLocation(paramInfo.ParameterType); } } else { - args = new ArgumentReference[fields.Length]; + args = new ArgumentLocation[fields.Length]; } for (var i = 0; i < fields.Length; i++) { - args[i] = new ArgumentReference(fields[i].Reference.FieldType); + args[i] = new ArgumentLocation(fields[i].Reference.FieldType); } var constructor = emitter.CreateConstructor(args); @@ -271,7 +271,7 @@ protected void GenerateConstructor(ClassEmitter emitter, ConstructorInfo baseCon { Debug.Assert(baseConstructorParams != null); - var slice = new ArgumentReference[baseConstructorParams.Length]; + var slice = new ArgumentLocation[baseConstructorParams.Length]; Array.Copy(args, fields.Length, slice, 0, baseConstructorParams.Length); constructor.CodeBuilder.AddStatement(new ConstructorInvocationStatement(baseConstructor, slice)); @@ -284,7 +284,7 @@ protected void GenerateConstructor(ClassEmitter emitter, ConstructorInfo baseCon constructor.CodeBuilder.AddStatement(new ReturnStatement()); } - protected void GenerateConstructors(ClassEmitter emitter, Type baseType, params FieldReference[] fields) + protected void GenerateConstructors(ClassEmitter emitter, Type baseType, params FieldLocation[] fields) { var constructors = baseType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); @@ -307,7 +307,7 @@ protected void GenerateConstructors(ClassEmitter emitter, Type baseType, params /// This constructor is important to allow proxies to be XML serializable /// /// - protected void GenerateParameterlessConstructor(ClassEmitter emitter, Type baseClass, FieldReference interceptorField) + protected void GenerateParameterlessConstructor(ClassEmitter emitter, Type baseClass, FieldLocation interceptorField) { // Check if the type actually has a default constructor var defaultConstructor = baseClass.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, Type.EmptyTypes, @@ -332,7 +332,7 @@ protected void GenerateParameterlessConstructor(ClassEmitter emitter, Type baseC new NewArrayExpression(1, typeof(IInterceptor)))); constructor.CodeBuilder.AddStatement( new AssignStatement( - new ArrayElementReference(interceptorField, 0), + new ArrayElementLocation(interceptorField, 0), new NewInstanceExpression(typeof(StandardInterceptor)))); // Invoke base constructor diff --git a/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs index dbd9af7221..12b3383d69 100644 --- a/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/ClassProxyGenerator.cs @@ -29,7 +29,7 @@ public ClassProxyGenerator(ModuleScope scope, Type targetType, Type[] interfaces { } - protected override FieldReference TargetField => null; + protected override FieldLocation TargetField => null; protected override CacheKey GetCacheKey() { diff --git a/src/Castle.Core/DynamicProxy/Generators/ClassProxyWithTargetGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/ClassProxyWithTargetGenerator.cs index 97232d624c..ba5c55f2e2 100644 --- a/src/Castle.Core/DynamicProxy/Generators/ClassProxyWithTargetGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/ClassProxyWithTargetGenerator.cs @@ -29,7 +29,7 @@ namespace Castle.DynamicProxy.Generators internal sealed class ClassProxyWithTargetGenerator : BaseClassProxyGenerator { - private FieldReference targetField; + private FieldLocation targetField; public ClassProxyWithTargetGenerator(ModuleScope scope, Type targetType, Type[] interfaces, ProxyGenerationOptions options) @@ -37,7 +37,7 @@ public ClassProxyWithTargetGenerator(ModuleScope scope, Type targetType, Type[] { } - protected override FieldReference TargetField => targetField; + protected override FieldLocation TargetField => targetField; protected override CacheKey GetCacheKey() { diff --git a/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs index f5f6975e21..316efe0625 100644 --- a/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/CompositionInvocationTypeGenerator.cs @@ -33,17 +33,17 @@ public CompositionInvocationTypeGenerator(Type target, MetaMethod method, Method { } - protected override ArgumentReference[] GetBaseCtorArguments(Type targetFieldType, + protected override ArgumentLocation[] GetBaseCtorArguments(Type targetFieldType, out ConstructorInfo baseConstructor) { baseConstructor = InvocationMethods.CompositionInvocationConstructor; return new[] { - new ArgumentReference(targetFieldType), - new ArgumentReference(typeof(object)), - new ArgumentReference(typeof(IInterceptor[])), - new ArgumentReference(typeof(MethodInfo)), - new ArgumentReference(typeof(object[])), + new ArgumentLocation(targetFieldType), + new ArgumentLocation(typeof(object)), + new ArgumentLocation(typeof(IInterceptor[])), + new ArgumentLocation(typeof(MethodInfo)), + new ArgumentLocation(typeof(object[])), }; } @@ -52,13 +52,13 @@ protected override Type GetBaseType() return BaseType; } - protected override FieldReference GetTargetField() + protected override FieldLocation GetTargetField() { - return new FieldReference(InvocationMethods.CompositionInvocationTarget); + return new FieldLocation(InvocationMethods.CompositionInvocationTarget); } protected override void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocation, ParameterInfo[] parameters, - MethodEmitter invokeMethodOnTarget, Reference targetField) + MethodEmitter invokeMethodOnTarget, Location targetField) { invokeMethodOnTarget.CodeBuilder.AddStatement( new MethodInvocationExpression( diff --git a/src/Castle.Core/DynamicProxy/Generators/DelegateTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/DelegateTypeGenerator.cs index 8efd6d40cf..7c356dfae0 100644 --- a/src/Castle.Core/DynamicProxy/Generators/DelegateTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/DelegateTypeGenerator.cs @@ -48,8 +48,8 @@ public AbstractTypeEmitter Generate(ClassEmitter @class, INamingScope namingScop private void BuildConstructor(AbstractTypeEmitter emitter) { - var constructor = emitter.CreateConstructor(new ArgumentReference(typeof(object)), - new ArgumentReference(typeof(IntPtr))); + var constructor = emitter.CreateConstructor(new ArgumentLocation(typeof(object)), + new ArgumentLocation(typeof(IntPtr))); constructor.ConstructorBuilder.SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed); } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/AbstractTypeEmitter.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/AbstractTypeEmitter.cs index 361a6bdf8e..6878e3f7b8 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/AbstractTypeEmitter.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/AbstractTypeEmitter.cs @@ -31,8 +31,8 @@ internal abstract class AbstractTypeEmitter private readonly List constructors; private readonly List events; - private readonly IDictionary fields = - new Dictionary(StringComparer.OrdinalIgnoreCase); + private readonly IDictionary fields = + new Dictionary(StringComparer.OrdinalIgnoreCase); private readonly List methods; @@ -114,7 +114,7 @@ public void CopyGenericParametersFromMethod(MethodInfo methodToCopyGenericsFrom) SetGenericTypeParameters(GenericUtil.CopyGenericArguments(methodToCopyGenericsFrom, typeBuilder)); } - public ConstructorEmitter CreateConstructor(params ArgumentReference[] arguments) + public ConstructorEmitter CreateConstructor(params ArgumentLocation[] arguments) { if (TypeBuilder.IsInterface) { @@ -143,12 +143,12 @@ public EventEmitter CreateEvent(string name, EventAttributes atts, Type type) return eventEmitter; } - public FieldReference CreateField(string name, Type fieldType) + public FieldLocation CreateField(string name, Type fieldType) { return CreateField(name, fieldType, true); } - public FieldReference CreateField(string name, Type fieldType, bool serializable) + public FieldLocation CreateField(string name, Type fieldType, bool serializable) { var atts = FieldAttributes.Private; @@ -160,10 +160,10 @@ public FieldReference CreateField(string name, Type fieldType, bool serializable return CreateField(name, fieldType, atts); } - public FieldReference CreateField(string name, Type fieldType, FieldAttributes atts) + public FieldLocation CreateField(string name, Type fieldType, FieldAttributes atts) { var fieldBuilder = typeBuilder.DefineField(name, fieldType, atts); - var reference = new FieldReference(fieldBuilder); + var reference = new FieldLocation(fieldBuilder); fields[name] = reference; return reference; } @@ -199,12 +199,12 @@ public PropertyEmitter CreateProperty(string name, PropertyAttributes attributes return propEmitter; } - public FieldReference CreateStaticField(string name, Type fieldType) + public FieldLocation CreateStaticField(string name, Type fieldType) { return CreateStaticField(name, fieldType, FieldAttributes.Private); } - public FieldReference CreateStaticField(string name, Type fieldType, FieldAttributes atts) + public FieldLocation CreateStaticField(string name, Type fieldType, FieldAttributes atts) { atts |= FieldAttributes.Static; return CreateField(name, fieldType, atts); @@ -235,7 +235,7 @@ public void DefineCustomAttribute(object[] constructorArguments) whe typeBuilder.SetCustomAttribute(customAttributeInfo.Builder); } - public void DefineCustomAttributeFor(FieldReference field) where TAttribute : Attribute, new() + public void DefineCustomAttributeFor(FieldLocation field) where TAttribute : Attribute, new() { var customAttributeInfo = AttributeUtil.CreateInfo(); var fieldBuilder = field.FieldBuilder; @@ -247,19 +247,19 @@ public void DefineCustomAttribute(object[] constructorArguments) whe fieldBuilder.SetCustomAttribute(customAttributeInfo.Builder); } - public IEnumerable GetAllFields() + public IEnumerable GetAllFields() { return fields.Values; } - public FieldReference GetField(string name) + public FieldLocation GetField(string name) { if (string.IsNullOrEmpty(name)) { return null; } - FieldReference value; + FieldLocation value; fields.TryGetValue(name, out value); return value; } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs index 8d91038bc1..64fe44f314 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs @@ -22,25 +22,25 @@ namespace Castle.DynamicProxy.Generators.Emitters internal abstract class ArgumentsUtil { - public static ArgumentReference[] ConvertToArgumentReference(Type[] args) + public static ArgumentLocation[] ConvertToArgumentReference(Type[] args) { - var arguments = new ArgumentReference[args.Length]; + var arguments = new ArgumentLocation[args.Length]; for (var i = 0; i < args.Length; ++i) { - arguments[i] = new ArgumentReference(args[i]); + arguments[i] = new ArgumentLocation(args[i]); } return arguments; } - public static ArgumentReference[] ConvertToArgumentReference(ParameterInfo[] args) + public static ArgumentLocation[] ConvertToArgumentReference(ParameterInfo[] args) { - var arguments = new ArgumentReference[args.Length]; + var arguments = new ArgumentLocation[args.Length]; for (var i = 0; i < args.Length; ++i) { - arguments[i] = new ArgumentReference(args[i].ParameterType); + arguments[i] = new ArgumentLocation(args[i].ParameterType); } return arguments; @@ -52,7 +52,7 @@ public static IExpression[] ConvertToArgumentReferenceExpression(ParameterInfo[] for (var i = 0; i < args.Length; ++i) { - arguments[i] = new ArgumentReference(args[i].ParameterType, i + 1); + arguments[i] = new ArgumentLocation(args[i].ParameterType, i + 1); } return arguments; @@ -68,7 +68,7 @@ public static Type[] GetTypes(ParameterInfo[] parameters) return types; } - public static Type[] InitializeAndConvert(ArgumentReference[] args) + public static Type[] InitializeAndConvert(ArgumentLocation[] args) { var types = new Type[args.Length]; @@ -81,7 +81,7 @@ public static Type[] InitializeAndConvert(ArgumentReference[] args) return types; } - public static void InitializeArgumentsByPosition(ArgumentReference[] args, bool isStatic) + public static void InitializeArgumentsByPosition(ArgumentLocation[] args, bool isStatic) { var offset = isStatic ? 0 : 1; for (var i = 0; i < args.Length; ++i) diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/CodeBuilder.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/CodeBuilder.cs index 606e975431..1344f16ea8 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/CodeBuilder.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/CodeBuilder.cs @@ -22,14 +22,14 @@ namespace Castle.DynamicProxy.Generators.Emitters internal sealed class CodeBuilder { - private readonly List locals; + private readonly List locals; private readonly List statements; private bool isEmpty; public CodeBuilder() { statements = new List(); - locals = new List(); + locals = new List(); isEmpty = true; } @@ -45,9 +45,9 @@ public CodeBuilder AddStatement(IStatement statement) return this; } - public LocalReference DeclareLocal(Type type) + public LocalLocation DeclareLocal(Type type) { - var local = new LocalReference(type); + var local = new LocalLocation(type); locals.Add(local); return local; } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/ConstructorEmitter.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/ConstructorEmitter.cs index 74b2edac37..dcfe1762d7 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/ConstructorEmitter.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/ConstructorEmitter.cs @@ -33,7 +33,7 @@ protected internal ConstructorEmitter(AbstractTypeEmitter mainType, ConstructorB codeBuilder = new CodeBuilder(); } - internal ConstructorEmitter(AbstractTypeEmitter mainType, params ArgumentReference[] arguments) + internal ConstructorEmitter(AbstractTypeEmitter mainType, params ArgumentLocation[] arguments) { this.mainType = mainType; diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/MethodEmitter.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/MethodEmitter.cs index 7d2579f10f..85f95bc81f 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/MethodEmitter.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/MethodEmitter.cs @@ -32,7 +32,7 @@ internal class MethodEmitter : IMemberEmitter private readonly CodeBuilder codeBuilder; private readonly GenericTypeParameterBuilder[] genericTypeParams; - private ArgumentReference[] arguments; + private ArgumentLocation[] arguments; protected internal MethodEmitter(MethodBuilder builder) { @@ -73,7 +73,7 @@ internal MethodEmitter(AbstractTypeEmitter owner, string name, DefineParameters(baseMethodParameters); } - public ArgumentReference[] Arguments + public ArgumentLocation[] Arguments { get { return arguments; } } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentLocation.cs similarity index 79% rename from src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs rename to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentLocation.cs index c1f911950e..17635d3893 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentLocation.cs @@ -19,28 +19,28 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST using System.Reflection.Emit; [DebuggerDisplay("argument {Type}")] - internal class ArgumentReference : Reference + internal class ArgumentLocation : Location { - public ArgumentReference(Type argumentType) - : base(argumentType) + public ArgumentLocation(Type type) + : base(type) { Position = -1; } - public ArgumentReference(Type argumentType, int position) - : base(argumentType) + public ArgumentLocation(Type type, int position) + : base(type) { Position = position; } internal int Position { get; set; } - public override void LoadAddressOfReference(ILGenerator gen) + public override void EmitLoadAddress(ILGenerator gen) { throw new NotSupportedException(); } - public override void LoadReference(ILGenerator gen) + public override void EmitLoad(ILGenerator gen) { if (Position == -1) { @@ -66,7 +66,7 @@ public override void LoadReference(ILGenerator gen) } } - public override void StoreReference(IExpression expression, ILGenerator gen) + public override void EmitStore(IExpression expression, ILGenerator gen) { if (Position == -1) { diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentsToObjectArrayExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentsToObjectArrayExpression.cs index ee08550e77..487d52c41b 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentsToObjectArrayExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArgumentsToObjectArrayExpression.cs @@ -21,9 +21,9 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST internal sealed class ArgumentsToObjectArrayExpression : IExpression { - private readonly Reference[] args; + private readonly Location[] args; - public ArgumentsToObjectArrayExpression(params Reference[] args) + public ArgumentsToObjectArrayExpression(params Location[] args) { this.args = args; } diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArrayElementReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArrayElementLocation.cs similarity index 88% rename from src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArrayElementReference.cs rename to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArrayElementLocation.cs index a07ef9aaca..acb4d0725e 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArrayElementReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ArrayElementLocation.cs @@ -17,12 +17,12 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST using System.Diagnostics; using System.Reflection.Emit; - internal sealed class ArrayElementReference : Reference + internal sealed class ArrayElementLocation : Location { - private readonly Reference array; + private readonly Location array; private readonly int index; - public ArrayElementReference(Reference array, int index) + public ArrayElementLocation(Location array, int index) : base(array.Type.GetElementType()) { Debug.Assert(array.Type.IsArray); @@ -32,14 +32,14 @@ public ArrayElementReference(Reference array, int index) this.index = index; } - public override void LoadAddressOfReference(ILGenerator gen) + public override void EmitLoadAddress(ILGenerator gen) { array.Emit(gen); LiteralIntExpression.Emit(index, gen); gen.Emit(OpCodes.Ldelema); } - public override void LoadReference(ILGenerator gen) + public override void EmitLoad(ILGenerator gen) { array.Emit(gen); LiteralIntExpression.Emit(index, gen); @@ -58,7 +58,7 @@ public override void LoadReference(ILGenerator gen) // | classes and interfaces | ldelem.ref } - public override void StoreReference(IExpression expression, ILGenerator gen) + public override void EmitStore(IExpression expression, ILGenerator gen) { array.Emit(gen); LiteralIntExpression.Emit(index, gen); diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs index 0fd1116908..379879aadf 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/AssignStatement.cs @@ -19,9 +19,9 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST internal class AssignStatement : IStatement { private readonly IExpression expression; - private readonly Reference target; + private readonly Location target; - public AssignStatement(Reference target, IExpression expression) + public AssignStatement(Location target, IExpression expression) { this.target = target; this.expression = expression; @@ -29,7 +29,7 @@ public AssignStatement(Reference target, IExpression expression) public void Emit(ILGenerator gen) { - target.StoreReference(expression, gen); + target.EmitStore(expression, gen); } } } \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefExpression.cs index e63a775ff3..69c56460ea 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefExpression.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ByRefExpression.cs @@ -20,16 +20,16 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST [DebuggerDisplay("&{reference}")] internal class ByRefExpression : IExpression { - private readonly Reference reference; + private readonly Location location; - public ByRefExpression(Reference reference) + public ByRefExpression(Location location) { - this.reference = reference; + this.location = location; } public void Emit(ILGenerator gen) { - reference.LoadAddressOfReference(gen); + location.EmitLoadAddress(gen); } } } \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldLocation.cs similarity index 86% rename from src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs rename to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldLocation.cs index e2d468bec2..9f2089abf2 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldLocation.cs @@ -19,13 +19,13 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST using System.Reflection.Emit; [DebuggerDisplay("{field.Name} ({field.FieldType})")] - internal class FieldReference : Reference + internal class FieldLocation : Location { private readonly FieldInfo field; private readonly FieldBuilder fieldBuilder; private readonly bool isStatic; - public FieldReference(FieldInfo field) + public FieldLocation(FieldInfo field) : base(field.FieldType) { this.field = field; @@ -35,7 +35,7 @@ public FieldReference(FieldInfo field) } } - public FieldReference(FieldBuilder fieldBuilder) + public FieldLocation(FieldBuilder fieldBuilder) : base(fieldBuilder.FieldType) { this.fieldBuilder = fieldBuilder; @@ -56,7 +56,7 @@ public FieldInfo Reference get { return @field; } } - public override void LoadAddressOfReference(ILGenerator gen) + public override void EmitLoadAddress(ILGenerator gen) { if (isStatic) { @@ -68,7 +68,7 @@ public override void LoadAddressOfReference(ILGenerator gen) } } - public override void LoadReference(ILGenerator gen) + public override void EmitLoad(ILGenerator gen) { var owner = isStatic ? null : ThisExpression.Instance; owner?.Emit(gen); @@ -82,7 +82,7 @@ public override void LoadReference(ILGenerator gen) } } - public override void StoreReference(IExpression expression, ILGenerator gen) + public override void EmitStore(IExpression expression, ILGenerator gen) { var owner = isStatic ? null : ThisExpression.Instance; owner?.Emit(gen); diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectLocation.cs similarity index 73% rename from src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs rename to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectLocation.cs index 17185d20b5..5bde7d05b9 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/IndirectLocation.cs @@ -24,11 +24,11 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST /// ByRef and provides indirect load/store support. /// [DebuggerDisplay("*{owner}")] - internal class IndirectReference : Reference + internal class IndirectLocation : Location { - private readonly Reference owner; + private readonly Location owner; - public IndirectReference(Reference byRefReference) : + public IndirectLocation(Location byRefReference) : base(byRefReference.Type.GetElementType()) { if (!byRefReference.Type.IsByRef) @@ -39,35 +39,35 @@ public IndirectReference(Reference byRefReference) : owner = byRefReference; } - public override void LoadAddressOfReference(ILGenerator gen) + public override void EmitLoadAddress(ILGenerator gen) { // Load of owner reference takes care of this. } // TODO: Better name - public override void LoadReference(ILGenerator gen) + public override void EmitLoad(ILGenerator gen) { owner.Emit(gen); OpCodeUtil.EmitLoadIndirectOpCodeForType(gen, Type); } - public override void StoreReference(IExpression expression, ILGenerator gen) + public override void EmitStore(IExpression expression, ILGenerator gen) { owner.Emit(gen); expression.Emit(gen); OpCodeUtil.EmitStoreIndirectOpCodeForType(gen, Type); } - public static Reference WrapIfByRef(Reference reference) + public static Location WrapIfByRef(Location reference) { - return reference.Type.IsByRef ? new IndirectReference(reference) : reference; + return reference.Type.IsByRef ? new IndirectLocation(reference) : reference; } // TODO: Better name - public static Reference[] WrapIfByRef(Reference[] references) + public static Location[] WrapIfByRef(Location[] references) { - var result = new Reference[references.Length]; + var result = new Location[references.Length]; for (var i = 0; i < references.Length; i++) { diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalLocation.cs similarity index 80% rename from src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs rename to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalLocation.cs index e4db3733d3..480e3139c8 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalLocation.cs @@ -19,11 +19,11 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST using System.Reflection.Emit; [DebuggerDisplay("local {Type}")] - internal class LocalReference : Reference + internal class LocalLocation : Location { private LocalBuilder localBuilder; - public LocalReference(Type type) + public LocalLocation(Type type) : base(type) { } @@ -33,17 +33,17 @@ public override void Generate(ILGenerator gen) localBuilder = gen.DeclareLocal(base.Type); } - public override void LoadAddressOfReference(ILGenerator gen) + public override void EmitLoadAddress(ILGenerator gen) { gen.Emit(OpCodes.Ldloca, localBuilder); } - public override void LoadReference(ILGenerator gen) + public override void EmitLoad(ILGenerator gen) { gen.Emit(OpCodes.Ldloc, localBuilder); } - public override void StoreReference(IExpression expression, ILGenerator gen) + public override void EmitStore(IExpression expression, ILGenerator gen) { expression.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/Location.cs similarity index 51% rename from src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs rename to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Location.cs index 57cb61933b..1a68db7dfc 100644 --- a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs +++ b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Location.cs @@ -19,11 +19,26 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST using System; using System.Reflection.Emit; - internal abstract class Reference : IExpression + // Locations as defined by ECMA-335 section I.8.3. + // They are typed and can each hold one value of that type. + // Managed pointers (&, or "by-refs") may refer to them. + // For that purpose, their address can be taken. + // + // There are four principal types of locations: + // + // 1. method arguments (see `ArgumentLocation`) + // 2. static and instance fields (see `FieldLocation`) + // 3. local variables (see `LocalLocation`) + // 4. array elements (see `ArrayElementLocation`) + // + // One additional helper location type, `IndirectLocation`, + // acts as a stand-in for any and all of the above + // to facilitate code generation involving by-refs. + internal abstract class Location : IExpression { protected readonly Type type; - protected Reference(Type type) + protected Location(Type type) { this.type = type; } @@ -33,11 +48,11 @@ public Type Type get { return type; } } - public abstract void LoadAddressOfReference(ILGenerator gen); + public abstract void EmitLoadAddress(ILGenerator gen); - public abstract void LoadReference(ILGenerator gen); + public abstract void EmitLoad(ILGenerator gen); - public abstract void StoreReference(IExpression expression, ILGenerator gen); + public abstract void EmitStore(IExpression expression, ILGenerator gen); public virtual void Generate(ILGenerator gen) { @@ -45,7 +60,7 @@ public virtual void Generate(ILGenerator gen) public void Emit(ILGenerator gen) { - LoadReference(gen); + EmitLoad(gen); } } } \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.cs b/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.cs index 6a01b29e6b..013c01102e 100644 --- a/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.cs +++ b/src/Castle.Core/DynamicProxy/Generators/GeneratorUtil.cs @@ -25,13 +25,13 @@ namespace Castle.DynamicProxy.Generators internal static class GeneratorUtil { - public static void CopyOutAndRefParameters(Reference[] dereferencedArguments, LocalReference invocation, + public static void CopyOutAndRefParameters(Location[] dereferencedArguments, LocalLocation invocation, MethodInfo method, MethodEmitter emitter) { var parameters = method.GetParameters(); // Create it only if there are byref writable arguments. - LocalReference arguments = null; + LocalLocation arguments = null; for (var i = 0; i < parameters.Length; i++) { @@ -131,23 +131,23 @@ bool IsReadOnly(ParameterInfo parameter) } } - private static ConvertExpression Argument(int i, LocalReference invocationArgs, Reference[] arguments) + private static ConvertExpression Argument(int i, LocalLocation invocationArgs, Location[] arguments) { - return new ConvertExpression(arguments[i].Type, new ArrayElementReference(invocationArgs, i)); + return new ConvertExpression(arguments[i].Type, new ArrayElementLocation(invocationArgs, i)); } - private static AssignStatement AssignArgument(Reference[] dereferencedArguments, int i, - LocalReference invocationArgs) + private static AssignStatement AssignArgument(Location[] dereferencedArguments, int i, + LocalLocation invocationArgs) { return new AssignStatement(dereferencedArguments[i], Argument(i, invocationArgs, dereferencedArguments)); } - private static AssignStatement GetArguments(LocalReference invocationArgs, LocalReference invocation) + private static AssignStatement GetArguments(LocalLocation invocationArgs, LocalLocation invocation) { return new AssignStatement(invocationArgs, new MethodInvocationExpression(invocation, InvocationMethods.GetArguments)); } - private static LocalReference StoreInvocationArgumentsInLocal(MethodEmitter emitter, LocalReference invocation) + private static LocalLocation StoreInvocationArgumentsInLocal(MethodEmitter emitter, LocalLocation invocation) { var invocationArgs = emitter.CodeBuilder.DeclareLocal(typeof(object[])); emitter.CodeBuilder.AddStatement(GetArguments(invocationArgs, invocation)); diff --git a/src/Castle.Core/DynamicProxy/Generators/InheritanceInvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InheritanceInvocationTypeGenerator.cs index 2ea9356782..c465770699 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InheritanceInvocationTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InheritanceInvocationTypeGenerator.cs @@ -32,17 +32,17 @@ public InheritanceInvocationTypeGenerator(Type targetType, MetaMethod method, Me { } - protected override ArgumentReference[] GetBaseCtorArguments(Type targetFieldType, + protected override ArgumentLocation[] GetBaseCtorArguments(Type targetFieldType, out ConstructorInfo baseConstructor) { baseConstructor = InvocationMethods.InheritanceInvocationConstructor; return new[] { - new ArgumentReference(typeof(Type)), - new ArgumentReference(typeof(object)), - new ArgumentReference(typeof(IInterceptor[])), - new ArgumentReference(typeof(MethodInfo)), - new ArgumentReference(typeof(object[])) + new ArgumentLocation(typeof(Type)), + new ArgumentLocation(typeof(object)), + new ArgumentLocation(typeof(IInterceptor[])), + new ArgumentLocation(typeof(MethodInfo)), + new ArgumentLocation(typeof(object[])) }; } @@ -51,9 +51,9 @@ protected override Type GetBaseType() return BaseType; } - protected override FieldReference GetTargetField() + protected override FieldLocation GetTargetField() { - return new FieldReference(InvocationMethods.ProxyObject); + return new FieldLocation(InvocationMethods.ProxyObject); } } } \ No newline at end of file diff --git a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs index dd91c22fa2..e1de93a982 100644 --- a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs @@ -46,12 +46,12 @@ protected InvocationTypeGenerator(Type targetType, MetaMethod method, MethodInfo /// Generates the constructor for the class that extends /// /// - protected abstract ArgumentReference[] GetBaseCtorArguments(Type targetFieldType, + protected abstract ArgumentLocation[] GetBaseCtorArguments(Type targetFieldType, out ConstructorInfo baseConstructor); protected abstract Type GetBaseType(); - protected abstract FieldReference GetTargetField(); + protected abstract FieldLocation GetTargetField(); public AbstractTypeEmitter Generate(ClassEmitter @class, INamingScope namingScope) { @@ -88,7 +88,7 @@ public AbstractTypeEmitter Generate(ClassEmitter @class, INamingScope namingScop protected virtual MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, IExpression[] args, MethodInfo callbackMethod, - Reference targetField, + Location targetField, MethodEmitter invokeMethodOnTarget) { if (contributor != null) @@ -104,7 +104,7 @@ protected virtual MethodInvocationExpression GetCallbackMethodInvocation(Abstrac protected virtual void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocation, ParameterInfo[] parameters, MethodEmitter invokeMethodOnTarget, - Reference targetField) + Location targetField) { var callbackMethod = GetCallbackMethod(invocation); if (callbackMethod == null) @@ -117,7 +117,7 @@ protected virtual void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocat // Idea: instead of grab parameters one by one // we should grab an array - var byRefArguments = new Dictionary(); + var byRefArguments = new Dictionary(); for (var i = 0; i < parameters.Length; i++) { @@ -184,7 +184,7 @@ protected virtual void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocat var methodOnTargetInvocationExpression = GetCallbackMethodInvocation(invocation, args, callbackMethod, targetField, invokeMethodOnTarget); - LocalReference returnValue = null; + LocalLocation returnValue = null; if (callbackMethod.ReturnType != typeof(void)) { var returnType = invocation.GetClosedParameterType(callbackMethod.ReturnType); @@ -228,7 +228,7 @@ protected virtual void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocat invokeMethodOnTarget.CodeBuilder.AddStatement(new ReturnStatement()); } - private void AssignBackByRefArguments(MethodEmitter invokeMethodOnTarget, Dictionary byRefArguments) + private void AssignBackByRefArguments(MethodEmitter invokeMethodOnTarget, Dictionary byRefArguments) { if (byRefArguments.Count == 0) { @@ -278,7 +278,7 @@ private void CreateConstructor(AbstractTypeEmitter invocation) constructor.CodeBuilder.AddStatement(new ReturnStatement()); } - private ConstructorEmitter CreateConstructor(AbstractTypeEmitter invocation, ArgumentReference[] baseCtorArguments) + private ConstructorEmitter CreateConstructor(AbstractTypeEmitter invocation, ArgumentLocation[] baseCtorArguments) { if (contributor == null) { @@ -325,13 +325,13 @@ private AbstractTypeEmitter GetEmitter(ClassEmitter @class, Type[] interfaces, I } private void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocation, ParameterInfo[] parameters, - FieldReference targetField, MethodInfo callbackMethod) + FieldLocation targetField, MethodInfo callbackMethod) { var invokeMethodOnTarget = invocation.CreateMethod("InvokeMethodOnTarget", typeof(void)); ImplementInvokeMethodOnTarget(invocation, parameters, invokeMethodOnTarget, targetField); } - private void ImplementChangeInvocationTarget(AbstractTypeEmitter invocation, FieldReference targetField) + private void ImplementChangeInvocationTarget(AbstractTypeEmitter invocation, FieldLocation targetField) { var changeInvocationTarget = invocation.CreateMethod("ChangeInvocationTarget", typeof(void), new[] { typeof(object) }); changeInvocationTarget.CodeBuilder.AddStatement( @@ -344,7 +344,7 @@ private void ImplementChangeProxyTarget(AbstractTypeEmitter invocation, ClassEmi { var changeProxyTarget = invocation.CreateMethod("ChangeProxyTarget", typeof(void), new[] { typeof(object) }); - var proxyObject = new FieldReference(InvocationMethods.ProxyObject); + var proxyObject = new FieldLocation(InvocationMethods.ProxyObject); var localProxy = changeProxyTarget.CodeBuilder.DeclareLocal(typeof(IProxyTargetAccessor)); changeProxyTarget.CodeBuilder.AddStatement( new AssignStatement(localProxy, @@ -362,7 +362,7 @@ private void ImplementChangeProxyTarget(AbstractTypeEmitter invocation, ClassEmi } private void ImplementChangeProxyTargetInterface(ClassEmitter @class, AbstractTypeEmitter invocation, - FieldReference targetField) + FieldLocation targetField) { ImplementChangeInvocationTarget(invocation, targetField); diff --git a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs index 5bb871ad47..9c53850da8 100644 --- a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs @@ -57,7 +57,7 @@ public MethodWithInvocationGenerator(MetaMethod method, IExpression interceptors this.contributor = contributor; } - protected FieldReference BuildMethodInterceptorsField(ClassEmitter @class, MethodInfo method, INamingScope namingScope) + protected FieldLocation BuildMethodInterceptorsField(ClassEmitter @class, MethodInfo method, INamingScope namingScope) { var methodInterceptors = @class.CreateField( namingScope.GetUniqueName(string.Format("interceptors_{0}", method.Name)), @@ -101,7 +101,7 @@ protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, C var methodInterceptors = SetMethodInterceptors(@class, namingScope, emitter, proxiedMethodTokenExpression); - var dereferencedArguments = IndirectReference.WrapIfByRef(emitter.Arguments); + var dereferencedArguments = IndirectLocation.WrapIfByRef(emitter.Arguments); var hasByRefArguments = HasByRefArguments(emitter.Arguments); var arguments = GetCtorArguments(@class, proxiedMethodTokenExpression, dereferencedArguments, methodInterceptors); @@ -158,7 +158,7 @@ protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, C // Emit code to ensure a value type return type is not null, otherwise the cast will cause a null-deref if (emitter.ReturnType.IsValueType && !emitter.ReturnType.IsNullableType()) { - LocalReference returnValue = emitter.CodeBuilder.DeclareLocal(typeof(object)); + LocalLocation returnValue = emitter.CodeBuilder.DeclareLocal(typeof(object)); emitter.CodeBuilder.AddStatement(new AssignStatement(returnValue, retVal)); emitter.CodeBuilder.AddStatement(new IfNullExpression(returnValue, new ThrowStatement(typeof(InvalidOperationException), @@ -212,7 +212,7 @@ private IExpression SetMethodInterceptors(ClassEmitter @class, INamingScope nami return methodInterceptorsField; } - private void EmitLoadGenericMethodArguments(MethodEmitter methodEmitter, MethodInfo method, Reference invocationLocal) + private void EmitLoadGenericMethodArguments(MethodEmitter methodEmitter, MethodInfo method, Location invocationLocal) { var genericParameters = Array.FindAll(method.GetGenericArguments(), t => t.IsGenericParameter); var genericParamsArrayLocal = methodEmitter.CodeBuilder.DeclareLocal(typeof(Type[])); @@ -223,7 +223,7 @@ private void EmitLoadGenericMethodArguments(MethodEmitter methodEmitter, MethodI { methodEmitter.CodeBuilder.AddStatement( new AssignStatement( - new ArrayElementReference(genericParamsArrayLocal, i), + new ArrayElementLocation(genericParamsArrayLocal, i), new TypeTokenExpression(genericParameters[i]))); } methodEmitter.CodeBuilder.AddStatement( @@ -232,7 +232,7 @@ private void EmitLoadGenericMethodArguments(MethodEmitter methodEmitter, MethodI genericParamsArrayLocal)); } - private IExpression[] GetCtorArguments(ClassEmitter @class, IExpression proxiedMethodTokenExpression, Reference[] dereferencedArguments, IExpression methodInterceptors) + private IExpression[] GetCtorArguments(ClassEmitter @class, IExpression proxiedMethodTokenExpression, Location[] dereferencedArguments, IExpression methodInterceptors) { return new[] { @@ -254,7 +254,7 @@ private IExpression[] ModifyArguments(ClassEmitter @class, IExpression[] argumen return contributor.GetConstructorInvocationArguments(arguments, @class); } - private bool HasByRefArguments(ArgumentReference[] arguments) + private bool HasByRefArguments(ArgumentLocation[] arguments) { for (int i = 0; i < arguments.Length; i++ ) { diff --git a/src/Castle.Core/DynamicProxy/Generators/MinimalisticMethodGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/MinimalisticMethodGenerator.cs index 7b7ce3511c..6935e21d1d 100644 --- a/src/Castle.Core/DynamicProxy/Generators/MinimalisticMethodGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/MinimalisticMethodGenerator.cs @@ -53,8 +53,8 @@ private void InitOutParameters(MethodEmitter emitter, ParameterInfo[] parameters { emitter.CodeBuilder.AddStatement( new AssignStatement( - new IndirectReference( - new ArgumentReference(parameter.ParameterType, index + 1)), + new IndirectLocation( + new ArgumentLocation(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 index 66313ea9dd..c54d582ca0 100644 --- a/src/Castle.Core/DynamicProxy/Generators/OptionallyForwardingMethodGenerator.cs +++ b/src/Castle.Core/DynamicProxy/Generators/OptionallyForwardingMethodGenerator.cs @@ -85,8 +85,8 @@ private void InitOutParameters(BlockStatement statements, ParameterInfo[] parame { statements.AddStatement( new AssignStatement( - new IndirectReference( - new ArgumentReference(parameter.ParameterType, index + 1)), + new IndirectLocation( + new ArgumentLocation(parameter.ParameterType, index + 1)), new DefaultValueExpression(parameter.ParameterType.GetElementType()))); } }