How to use NewInstanceExpression class of Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST package

1// Copyright 2004-2011 Castle Project - http://www.castleproject.org/
2// 
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6// 
7//   http://www.apache.org/licenses/LICENSE-2.0
8// 
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15namespace Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST
16{
17	using System;
18	using System.Reflection;
19	using System.Reflection.Emit;
20
21	internal class NewInstanceExpression : Expression
22	{
23		private readonly Expression[] arguments;
24		private readonly Type[] constructorArgs;
25		private readonly Type type;
26		private ConstructorInfo constructor;
27
28		public NewInstanceExpression(ConstructorInfo constructor, params Expression[] args)
29		{
30			this.constructor = constructor;
31			arguments = args;
32		}
33
34		public NewInstanceExpression(Type target, Type[] constructor_args, params Expression[] args)
35		{
36			type = target;
37			constructorArgs = constructor_args;
38			arguments = args;
39		}
40
41		public override void Emit(IMemberEmitter member, ILGenerator gen)
42		{
43			foreach (var exp in arguments)
44			{
45				exp.Emit(member, gen);
46			}
47
48			if (constructor == null)
49			{
50				constructor = type.GetConstructor(constructorArgs);
51			}
52
53			if (constructor == null)
54			{
55				throw new ProxyGenerationException("Could not find constructor matching specified arguments");
56			}
57
58			gen.Emit(OpCodes.Newobj, constructor);
59		}
60	}
61}

Source: NewInstanceExpression.cs

// Copyright 2004-2011 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 Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST
{
	using System;
	using System.Reflection;
	using System.Reflection.Emit;

	internal class NewInstanceExpression : Expression
	{
		private readonly Expression[] arguments;
		private readonly Type[] constructorArgs;
		private readonly Type type;
		private ConstructorInfo constructor;

		public NewInstanceExpression(ConstructorInfo constructor, params Expression[] args)
		{
			this.constructor = constructor;
			arguments = args;
		}

		public NewInstanceExpression(Type target, Type[] constructor_args, params Expression[] args)
		{
			type = target;
			constructorArgs = constructor_args;
			arguments = args;
		}

		public override void Emit(IMemberEmitter member, ILGenerator gen)
		{
			foreach (var exp in arguments)
			{
				exp.Emit(member, gen);
			}

			if (constructor == null)
			{
				constructor = type.GetConstructor(constructorArgs);
			}

			if (constructor == null)
			{
				throw new ProxyGenerationException("Could not find constructor matching specified arguments");
			}

			gen.Emit(OpCodes.Newobj, constructor);
		}
	}
}

1// Copyright 2004-2011 Castle Project - http://www.castleproject.org/
2// 
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6// 
7//   http://www.apache.org/licenses/LICENSE-2.0
8// 
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15namespace Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST
16{
17	using System;
18	using System.Reflection.Emit;
19
20	internal class ThrowStatement : Statement
21	{
22		private readonly string errorMessage;
23		private readonly Type exceptionType;
24
25		public ThrowStatement(Type exceptionType, String errorMessage)
26		{
27			this.exceptionType = exceptionType;
28			this.errorMessage = errorMessage;
29		}
30
31		public override void Emit(IMemberEmitter member, ILGenerator gen)
32		{
33			var ci = exceptionType.GetConstructor(new[] { typeof(String) });
34			var constRef = new ConstReference(errorMessage);
35
36			var creationStmt = new NewInstanceExpression(ci, constRef.ToExpression());
37
38			creationStmt.Emit(member, gen);
39
40			gen.Emit(OpCodes.Throw);
41		}
42	}
43}

Source: ThrowStatement.cs

// Copyright 2004-2011 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 Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST
{
	using System;
	using System.Reflection.Emit;

	internal class ThrowStatement : Statement
	{
		private readonly string errorMessage;
		private readonly Type exceptionType;

		public ThrowStatement(Type exceptionType, String errorMessage)
		{
			this.exceptionType = exceptionType;
			this.errorMessage = errorMessage;
		}

		public override void Emit(IMemberEmitter member, ILGenerator gen)
		{
			var ci = exceptionType.GetConstructor(new[] { typeof(String) });
			var constRef = new ConstReference(errorMessage);

			var creationStmt = new NewInstanceExpression(ci, constRef.ToExpression());

			creationStmt.Emit(member, gen);

			gen.Emit(OpCodes.Throw);
		}
	}
}

1// Copyright 2004-2011 Castle Project - http://www.castleproject.org/
2// 
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6// 
7//   http://www.apache.org/licenses/LICENSE-2.0
8// 
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15namespace Telerik.JustMock.Core.Castle.DynamicProxy.Generators
16{
17	using System;
18	using System.Diagnostics;
19	using System.Reflection;
20	using System.Reflection.Emit;
21#if FEATURE_SERIALIZATION
22	using System.Xml.Serialization;
23#endif
24
25	using Telerik.JustMock.Core.Castle.Core.Internal;
26	using Telerik.JustMock.Core.Castle.DynamicProxy.Contributors;
27	using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;
28	using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;
29	using Telerik.JustMock.Core.Castle.DynamicProxy.Internal;
30	using Telerik.JustMock.Core.Castle.DynamicProxy.Tokens;
31
32	internal class MethodWithInvocationGenerator : MethodGenerator
33	{
34		private readonly IInvocationCreationContributor contributor;
35		private readonly GetTargetExpressionDelegate getTargetExpression;
36		private readonly GetTargetExpressionDelegate getTargetTypeExpression;
37		private readonly Reference interceptors;
38		private readonly Type invocation;
39
40		public MethodWithInvocationGenerator(MetaMethod method, Reference interceptors, Type invocation,
41		                                     GetTargetExpressionDelegate getTargetExpression,
42		                                     OverrideMethodDelegate createMethod, IInvocationCreationContributor contributor)
43			: this(method, interceptors, invocation, getTargetExpression, null, createMethod, contributor)
44		{
45		}
46
47		public MethodWithInvocationGenerator(MetaMethod method, Reference interceptors, Type invocation,
48		                                     GetTargetExpressionDelegate getTargetExpression,
49		                                     GetTargetExpressionDelegate getTargetTypeExpression,
50		                                     OverrideMethodDelegate createMethod, IInvocationCreationContributor contributor)
51			: base(method, createMethod)
52		{
53			this.invocation = invocation;
54			this.getTargetExpression = getTargetExpression;
55			this.getTargetTypeExpression = getTargetTypeExpression;
56			this.interceptors = interceptors;
57			this.contributor = contributor;
58		}
59
60		protected FieldReference BuildMethodInterceptorsField(ClassEmitter @class, MethodInfo method, INamingScope namingScope)
61		{
62			var methodInterceptors = @class.CreateField(
63				namingScope.GetUniqueName(string.Format("interceptors_{0}", method.Name)),
64				typeof(IInterceptor[]),
65				false);
66#if FEATURE_SERIALIZATION
67			@class.DefineCustomAttributeFor<XmlIgnoreAttribute>(methodInterceptors);
68#endif
69			return methodInterceptors;
70		}
71
72		protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, ProxyGenerationOptions options, INamingScope namingScope)
73		{
74			var invocationType = invocation;
75
76			Trace.Assert(MethodToOverride.IsGenericMethod == invocationType.GetTypeInfo().IsGenericTypeDefinition);
77			var genericArguments = Type.EmptyTypes;
78
79			var constructor = invocation.GetConstructors()[0];
80
81			Expression proxiedMethodTokenExpression;
82			if (MethodToOverride.IsGenericMethod)
83			{
84				// bind generic method arguments to invocation's type arguments
85				genericArguments = emitter.MethodBuilder.GetGenericArguments();
86				invocationType = invocationType.MakeGenericType(genericArguments);
87				constructor = TypeBuilder.GetConstructor(invocationType, constructor);
88
89				// Not in the cache: generic method
90				proxiedMethodTokenExpression = new MethodTokenExpression(MethodToOverride.MakeGenericMethod(genericArguments));
91			}
92			else
93			{
94				var proxiedMethodToken = @class.CreateStaticField(namingScope.GetUniqueName("token_" + MethodToOverride.Name), typeof(MethodInfo));
95				@class.ClassConstructor.CodeBuilder.AddStatement(new AssignStatement(proxiedMethodToken, new MethodTokenExpression(MethodToOverride)));
96
97				proxiedMethodTokenExpression = proxiedMethodToken.ToExpression();
98			}
99
100			var methodInterceptors = SetMethodInterceptors(@class, namingScope, emitter, proxiedMethodTokenExpression);
101
102			var dereferencedArguments = IndirectReference.WrapIfByRef(emitter.Arguments);
103			var hasByRefArguments = HasByRefArguments(emitter.Arguments);
104
105			var arguments = GetCtorArguments(@class, proxiedMethodTokenExpression, dereferencedArguments, methodInterceptors);
106			var ctorArguments = ModifyArguments(@class, arguments);
107
108			var invocationLocal = emitter.CodeBuilder.DeclareLocal(invocationType);
109			emitter.CodeBuilder.AddStatement(new AssignStatement(invocationLocal,
110			                                                     new NewInstanceExpression(constructor, ctorArguments)));
111
112			if (MethodToOverride.ContainsGenericParameters)
113			{
114				EmitLoadGenricMethodArguments(emitter, MethodToOverride.MakeGenericMethod(genericArguments), invocationLocal);
115			}
116
117			if (hasByRefArguments)
118			{
119				emitter.CodeBuilder.AddStatement(new TryStatement());
120			}
121
122			var proceed = new ExpressionStatement(new MethodInvocationExpression(invocationLocal, InvocationMethods.Proceed));
123			emitter.CodeBuilder.AddStatement(proceed);
124
125			if (hasByRefArguments)
126			{
127				emitter.CodeBuilder.AddStatement(new FinallyStatement());
128			}
129
130			GeneratorUtil.CopyOutAndRefParameters(dereferencedArguments, invocationLocal, MethodToOverride, emitter);
131
132			if (hasByRefArguments)
133			{
134				emitter.CodeBuilder.AddStatement(new EndExceptionBlockStatement());
135			}
136
137			if (MethodToOverride.ReturnType != typeof(void))
138			{
139				var getRetVal = new MethodInvocationExpression(invocationLocal, InvocationMethods.GetReturnValue);
140
141				// Emit code to ensure a value type return type is not null, otherwise the cast will cause a null-deref
142				if (emitter.ReturnType.GetTypeInfo().IsValueType && !emitter.ReturnType.IsNullableType())
143				{
144					LocalReference returnValue = emitter.CodeBuilder.DeclareLocal(typeof(object));
145					emitter.CodeBuilder.AddStatement(new AssignStatement(returnValue, getRetVal));
146
147					emitter.CodeBuilder.AddExpression(new IfNullExpression(returnValue, new ThrowStatement(typeof(InvalidOperationException),
148						"Interceptors failed to set a return value, or swallowed the exception thrown by the target")));
149				}
150
151				// Emit code to return with cast from ReturnValue
152				emitter.CodeBuilder.AddStatement(new ReturnStatement(new ConvertExpression(emitter.ReturnType, getRetVal)));
153			}
154			else
155			{
156				emitter.CodeBuilder.AddStatement(new ReturnStatement());
157			}
158
159			return emitter;
160		}
161
162		private Expression SetMethodInterceptors(ClassEmitter @class, INamingScope namingScope, MethodEmitter emitter, Expression proxiedMethodTokenExpression)
163		{
164			var selector = @class.GetField("__selector");
165			if(selector == null)
166			{
167				return null;
168			}
169
170			var methodInterceptorsField = BuildMethodInterceptorsField(@class, MethodToOverride, namingScope);
171
172			Expression targetTypeExpression;
173			if (getTargetTypeExpression != null)
174			{
175				targetTypeExpression = getTargetTypeExpression(@class, MethodToOverride);
176			}
177			else
178			{
179				targetTypeExpression = new MethodInvocationExpression(null, TypeUtilMethods.GetTypeOrNull, getTargetExpression(@class, MethodToOverride));
180			}
181
182			var emptyInterceptors = new NewArrayExpression(0, typeof(IInterceptor));
183			var selectInterceptors = new MethodInvocationExpression(selector, InterceptorSelectorMethods.SelectInterceptors,
184			                                                        targetTypeExpression,
185			                                                        proxiedMethodTokenExpression, interceptors.ToExpression())
186			{ VirtualCall = true };
187
188			emitter.CodeBuilder.AddExpression(
189				new IfNullExpression(methodInterceptorsField,
190				                     new AssignStatement(methodInterceptorsField,
191				                                         new NullCoalescingOperatorExpression(selectInterceptors, emptyInterceptors))));
192
193			return methodInterceptorsField.ToExpression();
194		}
195
196		private void EmitLoadGenricMethodArguments(MethodEmitter methodEmitter, MethodInfo method, Reference invocationLocal)
197		{
198			var genericParameters = method.GetGenericArguments().FindAll(t => t.GetTypeInfo().IsGenericParameter);
199			var genericParamsArrayLocal = methodEmitter.CodeBuilder.DeclareLocal(typeof(Type[]));
200			methodEmitter.CodeBuilder.AddStatement(
201				new AssignStatement(genericParamsArrayLocal, new NewArrayExpression(genericParameters.Length, typeof(Type))));
202
203			for (var i = 0; i < genericParameters.Length; ++i)
204			{
205				methodEmitter.CodeBuilder.AddStatement(
206					new AssignArrayStatement(genericParamsArrayLocal, i, new TypeTokenExpression(genericParameters[i])));
207			}
208			methodEmitter.CodeBuilder.AddExpression(
209				new MethodInvocationExpression(invocationLocal,
210				                               InvocationMethods.SetGenericMethodArguments,
211				                               new ReferenceExpression(
212					                               genericParamsArrayLocal)));
213		}
214
215		private Expression[] GetCtorArguments(ClassEmitter @class, Expression proxiedMethodTokenExpression, TypeReference[] dereferencedArguments, Expression methodInterceptors)
216		{
217			return new[]
218			{
219				getTargetExpression(@class, MethodToOverride),
220				SelfReference.Self.ToExpression(),
221				methodInterceptors ?? interceptors.ToExpression(),
222				proxiedMethodTokenExpression,
223				new ReferencesToObjectArrayExpression(dereferencedArguments)
224			};
225		}
226
227		private Expression[] ModifyArguments(ClassEmitter @class, Expression[] arguments)
228		{
229			if (contributor == null)
230			{
231				return arguments;
232			}
233
234			return contributor.GetConstructorInvocationArguments(arguments, @class);
235		}
236
237		private bool HasByRefArguments(ArgumentReference[] arguments)
238		{
239			for (int i = 0; i < arguments.Length; i++ )
240			{
241				if (arguments[i].Type.GetTypeInfo().IsByRef)
242				{
243					return true;
244				}
245			}
246
247			return false;
248		}
249	}
250}

Source: MethodWithInvocationGenerator.cs

// Copyright 2004-2011 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 Telerik.JustMock.Core.Castle.DynamicProxy.Generators
{
	using System;
	using System.Diagnostics;
	using System.Reflection;
	using System.Reflection.Emit;
#if FEATURE_SERIALIZATION
	using System.Xml.Serialization;
#endif

	using Telerik.JustMock.Core.Castle.Core.Internal;
	using Telerik.JustMock.Core.Castle.DynamicProxy.Contributors;
	using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;
	using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;
	using Telerik.JustMock.Core.Castle.DynamicProxy.Internal;
	using Telerik.JustMock.Core.Castle.DynamicProxy.Tokens;

	internal class MethodWithInvocationGenerator : MethodGenerator
	{
		private readonly IInvocationCreationContributor contributor;
		private readonly GetTargetExpressionDelegate getTargetExpression;
		private readonly GetTargetExpressionDelegate getTargetTypeExpression;
		private readonly Reference interceptors;
		private readonly Type invocation;

		public MethodWithInvocationGenerator(MetaMethod method, Reference interceptors, Type invocation,
		                                     GetTargetExpressionDelegate getTargetExpression,
		                                     OverrideMethodDelegate createMethod, IInvocationCreationContributor contributor)
			: this(method, interceptors, invocation, getTargetExpression, null, createMethod, contributor)
		{
		}

		public MethodWithInvocationGenerator(MetaMethod method, Reference interceptors, Type invocation,
		                                     GetTargetExpressionDelegate getTargetExpression,
		                                     GetTargetExpressionDelegate getTargetTypeExpression,
		                                     OverrideMethodDelegate createMethod, IInvocationCreationContributor contributor)
			: base(method, createMethod)
		{
			this.invocation = invocation;
			this.getTargetExpression = getTargetExpression;
			this.getTargetTypeExpression = getTargetTypeExpression;
			this.interceptors = interceptors;
			this.contributor = contributor;
		}

		protected FieldReference BuildMethodInterceptorsField(ClassEmitter @class, MethodInfo method, INamingScope namingScope)
		{
			var methodInterceptors = @class.CreateField(
				namingScope.GetUniqueName(string.Format("interceptors_{0}", method.Name)),
				typeof(IInterceptor[]),
				false);
#if FEATURE_SERIALIZATION
			@class.DefineCustomAttributeFor<XmlIgnoreAttribute>(methodInterceptors);
#endif
			return methodInterceptors;
		}

		protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, ProxyGenerationOptions options, INamingScope namingScope)
		{
			var invocationType = invocation;

			Trace.Assert(MethodToOverride.IsGenericMethod == invocationType.GetTypeInfo().IsGenericTypeDefinition);
			var genericArguments = Type.EmptyTypes;

			var constructor = invocation.GetConstructors()[0];

			Expression proxiedMethodTokenExpression;
			if (MethodToOverride.IsGenericMethod)
			{
				// bind generic method arguments to invocation's type arguments
				genericArguments = emitter.MethodBuilder.GetGenericArguments();
				invocationType = invocationType.MakeGenericType(genericArguments);
				constructor = TypeBuilder.GetConstructor(invocationType, constructor);

				// Not in the cache: generic method
				proxiedMethodTokenExpression = new MethodTokenExpression(MethodToOverride.MakeGenericMethod(genericArguments));
			}
			else
			{
				var proxiedMethodToken = @class.CreateStaticField(namingScope.GetUniqueName("token_" + MethodToOverride.Name), typeof(MethodInfo));
				@class.ClassConstructor.CodeBuilder.AddStatement(new AssignStatement(proxiedMethodToken, new MethodTokenExpression(MethodToOverride)));

				proxiedMethodTokenExpression = proxiedMethodToken.ToExpression();
			}

			var methodInterceptors = SetMethodInterceptors(@class, namingScope, emitter, proxiedMethodTokenExpression);

			var dereferencedArguments = IndirectReference.WrapIfByRef(emitter.Arguments);
			var hasByRefArguments = HasByRefArguments(emitter.Arguments);

			var arguments = GetCtorArguments(@class, proxiedMethodTokenExpression, dereferencedArguments, methodInterceptors);
			var ctorArguments = ModifyArguments(@class, arguments);

			var invocationLocal = emitter.CodeBuilder.DeclareLocal(invocationType);
			emitter.CodeBuilder.AddStatement(new AssignStatement(invocationLocal,
			                                                     new NewInstanceExpression(constructor, ctorArguments)));

			if (MethodToOverride.ContainsGenericParameters)
			{
				EmitLoadGenricMethodArguments(emitter, MethodToOverride.MakeGenericMethod(genericArguments), invocationLocal);
			}

			if (hasByRefArguments)
			{
				emitter.CodeBuilder.AddStatement(new TryStatement());
			}

			var proceed = new ExpressionStatement(new MethodInvocationExpression(invocationLocal, InvocationMethods.Proceed));
			emitter.CodeBuilder.AddStatement(proceed);

			if (hasByRefArguments)
			{
				emitter.CodeBuilder.AddStatement(new FinallyStatement());
			}

			GeneratorUtil.CopyOutAndRefParameters(dereferencedArguments, invocationLocal, MethodToOverride, emitter);

			if (hasByRefArguments)
			{
				emitter.CodeBuilder.AddStatement(new EndExceptionBlockStatement());
			}

			if (MethodToOverride.ReturnType != typeof(void))
			{
				var getRetVal = new MethodInvocationExpression(invocationLocal, InvocationMethods.GetReturnValue);

				// Emit code to ensure a value type return type is not null, otherwise the cast will cause a null-deref
				if (emitter.ReturnType.GetTypeInfo().IsValueType && !emitter.ReturnType.IsNullableType())
				{
					LocalReference returnValue = emitter.CodeBuilder.DeclareLocal(typeof(object));
					emitter.CodeBuilder.AddStatement(new AssignStatement(returnValue, getRetVal));

					emitter.CodeBuilder.AddExpression(new IfNullExpression(returnValue, new ThrowStatement(typeof(InvalidOperationException),
						"Interceptors failed to set a return value, or swallowed the exception thrown by the target")));
				}

				// Emit code to return with cast from ReturnValue
				emitter.CodeBuilder.AddStatement(new ReturnStatement(new ConvertExpression(emitter.ReturnType, getRetVal)));
			}
			else
			{
				emitter.CodeBuilder.AddStatement(new ReturnStatement());
			}

			return emitter;
		}

		private Expression SetMethodInterceptors(ClassEmitter @class, INamingScope namingScope, MethodEmitter emitter, Expression proxiedMethodTokenExpression)
		{
			var selector = @class.GetField("__selector");
			if(selector == null)
			{
				return null;
			}

			var methodInterceptorsField = BuildMethodInterceptorsField(@class, MethodToOverride, namingScope);

			Expression targetTypeExpression;
			if (getTargetTypeExpression != null)
			{
				targetTypeExpression = getTargetTypeExpression(@class, MethodToOverride);
			}
			else
			{
				targetTypeExpression = new MethodInvocationExpression(null, TypeUtilMethods.GetTypeOrNull, getTargetExpression(@class, MethodToOverride));
			}

			var emptyInterceptors = new NewArrayExpression(0, typeof(IInterceptor));
			var selectInterceptors = new MethodInvocationExpression(selector, InterceptorSelectorMethods.SelectInterceptors,
			                                                        targetTypeExpression,
			                                                        proxiedMethodTokenExpression, interceptors.ToExpression())
			{ VirtualCall = true };

			emitter.CodeBuilder.AddExpression(
				new IfNullExpression(methodInterceptorsField,
				                     new AssignStatement(methodInterceptorsField,
				                                         new NullCoalescingOperatorExpression(selectInterceptors, emptyInterceptors))));

			return methodInterceptorsField.ToExpression();
		}

		private void EmitLoadGenricMethodArguments(MethodEmitter methodEmitter, MethodInfo method, Reference invocationLocal)
		{
			var genericParameters = method.GetGenericArguments().FindAll(t => t.GetTypeInfo().IsGenericParameter);
			var genericParamsArrayLocal = methodEmitter.CodeBuilder.DeclareLocal(typeof(Type[]));
			methodEmitter.CodeBuilder.AddStatement(
				new AssignStatement(genericParamsArrayLocal, new NewArrayExpression(genericParameters.Length, typeof(Type))));

			for (var i = 0; i < genericParameters.Length; ++i)
			{
				methodEmitter.CodeBuilder.AddStatement(
					new AssignArrayStatement(genericParamsArrayLocal, i, new TypeTokenExpression(genericParameters[i])));
			}
			methodEmitter.CodeBuilder.AddExpression(
				new MethodInvocationExpression(invocationLocal,
				                               InvocationMethods.SetGenericMethodArguments,
				                               new ReferenceExpression(
					                               genericParamsArrayLocal)));
		}

		private Expression[] GetCtorArguments(ClassEmitter @class, Expression proxiedMethodTokenExpression, TypeReference[] dereferencedArguments, Expression methodInterceptors)
		{
			return new[]
			{
				getTargetExpression(@class, MethodToOverride),
				SelfReference.Self.ToExpression(),
				methodInterceptors ?? interceptors.ToExpression(),
				proxiedMethodTokenExpression,
				new ReferencesToObjectArrayExpression(dereferencedArguments)
			};
		}

		private Expression[] ModifyArguments(ClassEmitter @class, Expression[] arguments)
		{
			if (contributor == null)
			{
				return arguments;
			}

			return contributor.GetConstructorInvocationArguments(arguments, @class);
		}

		private bool HasByRefArguments(ArgumentReference[] arguments)
		{
			for (int i = 0; i < arguments.Length; i++ )
			{
				if (arguments[i].Type.GetTypeInfo().IsByRef)
				{
					return true;
				}
			}

			return false;
		}
	}
}