ReferenceExpression is no longer needed

stakx · stakx · commit 662317c49586 · 2021-02-01T00:56:21.000+01:00
because `Reference` can simply implement `IExpression` instead.
diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs
@@ -96,8 +96,8 @@ protected override void CustomizeGetObjectData(CodeBuilder codebuilder, Argument
 				new MethodInvocationExpression(
 					serializationInfo,
 					SerializationInfoMethods.AddValue_Bool,
-					new ConstReference("__delegateToBase").ToExpression(),
-					new ConstReference(delegateToBaseGetObjectData).ToExpression()));
+					new ConstReference("__delegateToBase"),
+					new ConstReference(delegateToBaseGetObjectData)));
 
 			if (delegateToBaseGetObjectData == false)
 			{
@@ -123,21 +123,21 @@ private void EmitCustomGetObjectData(CodeBuilder codebuilder, ArgumentReference
 			var callSort = new MethodInvocationExpression(
 				null,
 				TypeUtilMethods.Sort,
-				members.ToExpression());
+				members);
 			codebuilder.AddStatement(new AssignStatement(members, callSort));
 
 			var getObjectData = new MethodInvocationExpression(
 				null,
 				FormatterServicesMethods.GetObjectData,
-				SelfReference.Self.ToExpression(),
-				members.ToExpression());
+				SelfReference.Self,
+				members);
 			codebuilder.AddStatement(new AssignStatement(data, getObjectData));
 
 			var addValue = new MethodInvocationExpression(
 				serializationInfo,
 				SerializationInfoMethods.AddValue_Object,
-				new ConstReference("__data").ToExpression(),
-				data.ToExpression());
+				new ConstReference("__data"),
+				data);
 			codebuilder.AddStatement(addValue);
 		}
 
@@ -150,8 +150,8 @@ private void EmitCallToBaseGetObjectData(CodeBuilder codebuilder, ArgumentRefere
 			codebuilder.AddStatement(
 				new MethodInvocationExpression(
 					baseGetObjectData,
-					serializationInfo.ToExpression(),
-					streamingContext.ToExpression()));
+					serializationInfo,
+					streamingContext));
 		}
 
 		private void Constructor(ClassEmitter emitter)
@@ -172,14 +172,14 @@ private void GenerateSerializationConstructor(ClassEmitter emitter)
 
 			ctor.CodeBuilder.AddStatement(
 				new ConstructorInvocationStatement(serializationConstructor,
-				                                   serializationInfo.ToExpression(),
-				                                   streamingContext.ToExpression()));
+				                                   serializationInfo,
+				                                   streamingContext));
 
 			foreach (var field in serializedFields)
 			{
 				var getValue = new MethodInvocationExpression(serializationInfo,
 				                                              SerializationInfoMethods.GetValue,
-				                                              new ConstReference(field.Reference.Name).ToExpression(),
+				                                              new ConstReference(field.Reference.Name),
 				                                              new TypeTokenExpression(field.Reference.FieldType));
 				ctor.CodeBuilder.AddStatement(new AssignStatement(
 				                              	field,
diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyTargetContributor.cs
@@ -115,19 +115,13 @@ private MethodBuilder CreateCallbackMethod(ClassEmitter emitter, MethodInfo meth
 				targetMethod = targetMethod.MakeGenericMethod(callBackMethod.GenericTypeParams.AsTypeArray());
 			}
 
-			var exps = new IExpression[callBackMethod.Arguments.Length];
-			for (var i = 0; i < callBackMethod.Arguments.Length; i++)
-			{
-				exps[i] = callBackMethod.Arguments[i].ToExpression();
-			}
-
 			// invocation on base class
 
 			callBackMethod.CodeBuilder.AddStatement(
 				new ReturnStatement(
 					new MethodInvocationExpression(SelfReference.Self,
 					                               targetMethod,
-					                               exps)));
+					                               callBackMethod.Arguments)));
 
 			return callBackMethod.MethodBuilder;
 		}
diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxyWithTargetTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxyWithTargetTargetContributor.cs
@@ -76,7 +76,7 @@ protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEm
 			return new MethodWithInvocationGenerator(method,
 			                                         @class.GetField("__interceptors"),
 			                                         invocation,
-			                                         (c, m) => c.GetField("__target").ToExpression(),
+			                                         (c, m) => c.GetField("__target"),
 			                                         overrideMethod,
 			                                         null);
 		}
@@ -151,7 +151,7 @@ private MethodGenerator IndirectlyCalledMethodGenerator(MetaMethod method, Class
 			return new MethodWithInvocationGenerator(method,
 			                                         proxy.GetField("__interceptors"),
 			                                         invocation,
-			                                         (c, m) => c.GetField("__target").ToExpression(),
+			                                         (c, m) => c.GetField("__target"),
 			                                         overrideMethod,
 			                                         contributor);
 		}
diff --git a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxySerializableContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxySerializableContributor.cs
@@ -38,15 +38,15 @@ protected override void CustomizeGetObjectData(CodeBuilder codebuilder, Argument
 				new MethodInvocationExpression(
 					serializationInfo,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference("__targetFieldType").ToExpression(),
-					new ConstReference(targetField.Reference.FieldType.AssemblyQualifiedName).ToExpression()));
+					new ConstReference("__targetFieldType"),
+					new ConstReference(targetField.Reference.FieldType.AssemblyQualifiedName)));
 
 			codebuilder.AddStatement(
 				new MethodInvocationExpression(
 					serializationInfo,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference("__theInterface").ToExpression(),
-					new ConstReference(targetType.AssemblyQualifiedName).ToExpression()));
+					new ConstReference("__theInterface"),
+					new ConstReference(targetType.AssemblyQualifiedName)));
 		}
 	}
 }
diff --git a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyTargetContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxyTargetContributor.cs
@@ -68,7 +68,7 @@ protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEm
 			return new MethodWithInvocationGenerator(method,
 			                                         @class.GetField("__interceptors"),
 			                                         invocation,
-			                                         (c, m) => c.GetField("__target").ToExpression(),
+			                                         (c, m) => c.GetField("__target"),
 			                                         overrideMethod,
 			                                         null);
 		}
diff --git a/src/Castle.Core/DynamicProxy/Contributors/InvocationWithDelegateContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InvocationWithDelegateContributor.cs
@@ -46,7 +46,7 @@ public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArgument
 			var constructor = invocation.CreateConstructor(arguments);
 
 			var delegateField = invocation.CreateField("delegate", delegateType);
-			constructor.CodeBuilder.AddStatement(new AssignStatement(delegateField, new ReferenceExpression(arguments[0])));
+			constructor.CodeBuilder.AddStatement(new AssignStatement(delegateField, arguments[0]));
 			return constructor;
 		}
 
@@ -68,7 +68,7 @@ public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitte
 		public IExpression[] GetConstructorInvocationArguments(IExpression[] arguments, ClassEmitter proxy)
 		{
 			var allArguments = new IExpression[arguments.Length + 1];
-			allArguments[0] = new ReferenceExpression(BuildDelegateToken(proxy));
+			allArguments[0] = BuildDelegateToken(proxy);
 			Array.Copy(arguments, 0, allArguments, 1, arguments.Length);
 			return allArguments;
 		}
@@ -92,7 +92,7 @@ private IExpression[] GetAllArgs(IExpression[] args, Reference targetField)
 		{
 			var allArgs = new IExpression[args.Length + 1];
 			args.CopyTo(allArgs, 1);
-			allArgs[0] = new ConvertExpression(targetType, targetField.ToExpression());
+			allArgs[0] = new ConvertExpression(targetType, targetField);
 			return allArgs;
 		}
 
diff --git a/src/Castle.Core/DynamicProxy/Contributors/InvocationWithGenericDelegateContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InvocationWithGenericDelegateContributor.cs
@@ -68,13 +68,12 @@ private Reference GetDelegate(AbstractTypeEmitter invocation, MethodEmitter invo
 			var closedDelegateType = delegateType.MakeGenericType(genericTypeParameters);
 			var localReference = invokeMethodOnTarget.CodeBuilder.DeclareLocal(closedDelegateType);
 			var closedMethodOnTarget = method.MethodOnTarget.MakeGenericMethod(genericTypeParameters);
-			var localTarget = new ReferenceExpression(targetReference);
 			invokeMethodOnTarget.CodeBuilder.AddStatement(
-				SetDelegate(localReference, localTarget, closedDelegateType, closedMethodOnTarget));
+				SetDelegate(localReference, targetReference, closedDelegateType, closedMethodOnTarget));
 			return localReference;
 		}
 
-		private AssignStatement SetDelegate(LocalReference localDelegate, ReferenceExpression localTarget,
+		private AssignStatement SetDelegate(LocalReference localDelegate, Reference localTarget,
 		                                    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
@@ -111,12 +111,12 @@ private GetTargetExpressionDelegate BuildGetTargetExpression()
 		{
 			if (!canChangeTarget)
 			{
-				return (c, m) => fields[m.DeclaringType].ToExpression();
+				return (c, m) => fields[m.DeclaringType];
 			}
 
 			return (c, m) => new NullCoalescingOperatorExpression(
-			                 	new AsTypeReference(c.GetField("__target"), m.DeclaringType).ToExpression(),
-			                 	fields[m.DeclaringType].ToExpression());
+			                 	new AsTypeReference(c.GetField("__target"), m.DeclaringType),
+			                 	fields[m.DeclaringType]);
 		}
 
 		private FieldReference BuildTargetField(ClassEmitter @class, Type type)
diff --git a/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs
@@ -46,7 +46,7 @@ public void Generate(ClassEmitter emitter)
 			var dynProxyGetTarget = emitter.CreateMethod(nameof(IProxyTargetAccessor.DynProxyGetTarget), typeof(object));
 
 			dynProxyGetTarget.CodeBuilder.AddStatement(
-				new ReturnStatement(new ConvertExpression(typeof(object), targetType, targetReference.ToExpression())));
+				new ReturnStatement(new ConvertExpression(typeof(object), targetType, targetReference)));
 
 			var dynProxySetTarget = emitter.CreateMethod(nameof(IProxyTargetAccessor.DynProxySetTarget), typeof(void), typeof(object));
 
@@ -55,7 +55,7 @@ public void Generate(ClassEmitter emitter)
 			{
 				dynProxySetTarget.CodeBuilder.AddStatement(
 					new AssignStatement(targetField,
-						new ConvertExpression(targetField.Fieldbuilder.FieldType, dynProxySetTarget.Arguments[0].ToExpression())));
+						new ConvertExpression(targetField.Fieldbuilder.FieldType, dynProxySetTarget.Arguments[0])));
 			}
 			else
 			{
diff --git a/src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs
@@ -57,15 +57,15 @@ protected void ImplementGetObjectData(ClassEmitter emitter)
 					new MethodInvocationExpression(
 						null,
 						TypeMethods.StaticGetType,
-						new ConstReference(typeof(ProxyObjectReference).AssemblyQualifiedName).ToExpression(),
-						new ConstReference(1).ToExpression(),
-						new ConstReference(0).ToExpression())));
+						new ConstReference(typeof(ProxyObjectReference).AssemblyQualifiedName),
+						new ConstReference(1),
+						new ConstReference(0))));
 
 			getObjectData.CodeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					info,
 					SerializationInfoMethods.SetType,
-					typeLocal.ToExpression()));
+					typeLocal));
 
 			foreach (var field in emitter.GetAllFields())
 			{
@@ -93,36 +93,36 @@ protected void ImplementGetObjectData(ClassEmitter emitter)
 					new AssignArrayStatement(
 						interfacesLocal,
 						i,
-						new ConstReference(interfaces[i].AssemblyQualifiedName).ToExpression()));
+						new ConstReference(interfaces[i].AssemblyQualifiedName)));
 			}
 
 			getObjectData.CodeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					info,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference("__interfaces").ToExpression(),
-					interfacesLocal.ToExpression()));
+					new ConstReference("__interfaces"),
+					interfacesLocal));
 
 			getObjectData.CodeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					info,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference("__baseType").ToExpression(),
-					new ConstReference(emitter.BaseType.AssemblyQualifiedName).ToExpression()));
+					new ConstReference("__baseType"),
+					new ConstReference(emitter.BaseType.AssemblyQualifiedName)));
 
 			getObjectData.CodeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					info,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference("__proxyGenerationOptions").ToExpression(),
-					emitter.GetField("proxyGenerationOptions").ToExpression()));
+					new ConstReference("__proxyGenerationOptions"),
+					emitter.GetField("proxyGenerationOptions")));
 
 			getObjectData.CodeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					info,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference("__proxyTypeId").ToExpression(),
-					new ConstReference(proxyTypeId).ToExpression()));
+					new ConstReference("__proxyTypeId"),
+					new ConstReference(proxyTypeId)));
 
 			CustomizeGetObjectData(getObjectData.CodeBuilder, info, getObjectData.Arguments[1], emitter);
 
@@ -136,8 +136,8 @@ protected virtual void AddAddValueInvocation(ArgumentReference serializationInfo
 				new MethodInvocationExpression(
 					serializationInfo,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference(field.Reference.Name).ToExpression(),
-					field.ToExpression()));
+					new ConstReference(field.Reference.Name),
+					field));
 			return;
 		}
 
diff --git a/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs
@@ -262,7 +262,7 @@ protected void GenerateConstructor(ClassEmitter emitter, ConstructorInfo baseCon
 
 			for (var i = 0; i < fields.Length; i++)
 			{
-				constructor.CodeBuilder.AddStatement(new AssignStatement(fields[i], args[i].ToExpression()));
+				constructor.CodeBuilder.AddStatement(new AssignStatement(fields[i], args[i]));
 			}
 
 			// Invoke base constructor
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/ArgumentsUtil.cs
@@ -22,18 +22,6 @@ namespace Castle.DynamicProxy.Generators.Emitters
 
 	internal abstract class ArgumentsUtil
 	{
-		public static IExpression[] ConvertArgumentReferenceToExpression(ArgumentReference[] args)
-		{
-			var expressions = new IExpression[args.Length];
-
-			for (var i = 0; i < args.Length; ++i)
-			{
-				expressions[i] = args[i].ToExpression();
-			}
-
-			return expressions;
-		}
-
 		public static ArgumentReference[] ConvertToArgumentReference(Type[] args)
 		{
 			var arguments = new ArgumentReference[args.Length];
@@ -58,13 +46,13 @@ public static ArgumentReference[] ConvertToArgumentReference(ParameterInfo[] arg
 			return arguments;
 		}
 
-		public static ReferenceExpression[] ConvertToArgumentReferenceExpression(ParameterInfo[] args)
+		public static IExpression[] ConvertToArgumentReferenceExpression(ParameterInfo[] args)
 		{
-			var arguments = new ReferenceExpression[args.Length];
+			var arguments = new IExpression[args.Length];
 
 			for (var i = 0; i < args.Length; ++i)
 			{
-				arguments[i] = new ReferenceExpression(new ArgumentReference(args[i].ParameterType, i + 1));
+				arguments[i] = new ArgumentReference(args[i].ParameterType, i + 1);
 			}
 
 			return arguments;
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ConstructorInvocationStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ConstructorInvocationStatement.cs
@@ -43,11 +43,6 @@ public ConstructorInvocationStatement(ConstructorInfo method, params IExpression
 			this.args = args;
 		}
 
-		public ConstructorInvocationStatement(ConstructorInfo method, ArgumentReference[] args)
-			: this(method, ArgumentsUtil.ConvertArgumentReferenceToExpression(args))
-		{
-		}
-
 		public void Emit(IMemberEmitter member, ILGenerator gen)
 		{
 			gen.Emit(OpCodes.Ldarg_0);
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/Reference.cs
@@ -16,7 +16,7 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 {
 	using System.Reflection.Emit;
 
-	internal abstract class Reference
+	internal abstract class Reference : IExpression
 	{
 		protected Reference owner = SelfReference.Self;
 
@@ -50,9 +50,9 @@ public virtual IExpression ToAddressOfExpression()
 			return new AddressOfReferenceExpression(this);
 		}
 
-		public virtual IExpression ToExpression()
+		void IExpressionOrStatement.Emit(IMemberEmitter member, ILGenerator gen)
 		{
-			return new ReferenceExpression(this);
+			ArgumentsUtil.EmitLoadOwnerAndReference(this, gen);
 		}
 	}
 }
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferenceExpression.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ReferenceExpression.cs
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ThrowStatement.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ThrowStatement.cs
diff --git a/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetInterfaceGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InterfaceProxyWithTargetInterfaceGenerator.cs
diff --git a/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/InvocationTypeGenerator.cs
diff --git a/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs b/src/Castle.Core/DynamicProxy/Generators/MethodWithInvocationGenerator.cs

Original file line number	Diff line number	Diff line change
`@@ -38,15 +38,15 @@ protected override void CustomizeGetObjectData(CodeBuilder codebuilder, Argument`
`38`	`38`	`new MethodInvocationExpression(`
`39`	`39`	`serializationInfo,`
`40`	`40`	`SerializationInfoMethods.AddValue_Object,`
`41`		`- new ConstReference("__targetFieldType").ToExpression(),`
`42`		`- new ConstReference(targetField.Reference.FieldType.AssemblyQualifiedName).ToExpression()));`
	`41`	`+ new ConstReference("__targetFieldType"),`
	`42`	`+ new ConstReference(targetField.Reference.FieldType.AssemblyQualifiedName)));`
`43`	`43`
`44`	`44`	`codebuilder.AddStatement(`
`45`	`45`	`new MethodInvocationExpression(`
`46`	`46`	`serializationInfo,`
`47`	`47`	`SerializationInfoMethods.AddValue_Object,`
`48`		`- new ConstReference("__theInterface").ToExpression(),`
`49`		`- new ConstReference(targetType.AssemblyQualifiedName).ToExpression()));`
	`48`	`+ new ConstReference("__theInterface"),`
	`49`	`+ new ConstReference(targetType.AssemblyQualifiedName)));`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEm`
`68`	`68`	`return new MethodWithInvocationGenerator(method,`
`69`	`69`	`@class.GetField("__interceptors"),`
`70`	`70`	`invocation,`
`71`		`- (c, m) => c.GetField("__target").ToExpression(),`
	`71`	`+ (c, m) => c.GetField("__target"),`
`72`	`72`	`overrideMethod,`
`73`	`73`	`null);`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArgument`
`46`	`46`	`var constructor = invocation.CreateConstructor(arguments);`
`47`	`47`
`48`	`48`	`var delegateField = invocation.CreateField("delegate", delegateType);`
`49`		`- constructor.CodeBuilder.AddStatement(new AssignStatement(delegateField, new ReferenceExpression(arguments[0])));`
	`49`	`+ constructor.CodeBuilder.AddStatement(new AssignStatement(delegateField, arguments[0]));`
`50`	`50`	`return constructor;`
`51`	`51`	`}`
`52`	`52`
`@@ -68,7 +68,7 @@ public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitte`
`68`	`68`	`public IExpression[] GetConstructorInvocationArguments(IExpression[] arguments, ClassEmitter proxy)`
`69`	`69`	`{`
`70`	`70`	`var allArguments = new IExpression[arguments.Length + 1];`
`71`		`- allArguments[0] = new ReferenceExpression(BuildDelegateToken(proxy));`
	`71`	`+ allArguments[0] = BuildDelegateToken(proxy);`
`72`	`72`	`Array.Copy(arguments, 0, allArguments, 1, arguments.Length);`
`73`	`73`	`return allArguments;`
`74`	`74`	`}`
`@@ -92,7 +92,7 @@ private IExpression[] GetAllArgs(IExpression[] args, Reference targetField)`
`92`	`92`	`{`
`93`	`93`	`var allArgs = new IExpression[args.Length + 1];`
`94`	`94`	`args.CopyTo(allArgs, 1);`
`95`		`- allArgs[0] = new ConvertExpression(targetType, targetField.ToExpression());`
	`95`	`+ allArgs[0] = new ConvertExpression(targetType, targetField);`
`96`	`96`	`return allArgs;`
`97`	`97`	`}`
`98`	`98`
Original file line number	Diff line number	Diff line change
`@@ -111,12 +111,12 @@ private GetTargetExpressionDelegate BuildGetTargetExpression()`
`111`	`111`	`{`
`112`	`112`	`if (!canChangeTarget)`
`113`	`113`	`{`
`114`		`- return (c, m) => fields[m.DeclaringType].ToExpression();`
	`114`	`+ return (c, m) => fields[m.DeclaringType];`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`return (c, m) => new NullCoalescingOperatorExpression(`
`118`		`- new AsTypeReference(c.GetField("__target"), m.DeclaringType).ToExpression(),`
`119`		`- fields[m.DeclaringType].ToExpression());`
	`118`	`+ new AsTypeReference(c.GetField("__target"), m.DeclaringType),`
	`119`	`+ fields[m.DeclaringType]);`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`private FieldReference BuildTargetField(ClassEmitter @class, Type type)`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public void Generate(ClassEmitter emitter)`
`46`	`46`	`var dynProxyGetTarget = emitter.CreateMethod(nameof(IProxyTargetAccessor.DynProxyGetTarget), typeof(object));`
`47`	`47`
`48`	`48`	`dynProxyGetTarget.CodeBuilder.AddStatement(`
`49`		`- new ReturnStatement(new ConvertExpression(typeof(object), targetType, targetReference.ToExpression())));`
	`49`	`+ new ReturnStatement(new ConvertExpression(typeof(object), targetType, targetReference)));`
`50`	`50`
`51`	`51`	`var dynProxySetTarget = emitter.CreateMethod(nameof(IProxyTargetAccessor.DynProxySetTarget), typeof(void), typeof(object));`
`52`	`52`
`@@ -55,7 +55,7 @@ public void Generate(ClassEmitter emitter)`
`55`	`55`	`{`
`56`	`56`	`dynProxySetTarget.CodeBuilder.AddStatement(`
`57`	`57`	`new AssignStatement(targetField,`
`58`		`- new ConvertExpression(targetField.Fieldbuilder.FieldType, dynProxySetTarget.Arguments[0].ToExpression())));`
	`58`	`+ new ConvertExpression(targetField.Fieldbuilder.FieldType, dynProxySetTarget.Arguments[0])));`
`59`	`59`	`}`
`60`	`60`	`else`
`61`	`61`	`{`