How to use AddStatement method of Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.MultiStatementExpression class

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.Contributors
16{
17	using System;
18	using System.Reflection;
19
20	using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;
21	using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;
22	using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;
23
24	internal class OptionallyForwardingMethodGenerator : MethodGenerator
25	{
26		// TODO: This class largely duplicates code from Forwarding and Minimalistic generators. Should be refactored to change that
27		private readonly GetTargetReferenceDelegate getTargetReference;
28
29		public OptionallyForwardingMethodGenerator(MetaMethod method, OverrideMethodDelegate overrideMethod,
30		                                           GetTargetReferenceDelegate getTargetReference)
31			: base(method, overrideMethod)
32		{
33			this.getTargetReference = getTargetReference;
34		}
35
36		protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class,
37		                                                        ProxyGenerationOptions options, INamingScope namingScope)
38		{
39			var targetReference = getTargetReference(@class, MethodToOverride);
40
41			emitter.CodeBuilder.AddStatement(
42				new ExpressionStatement(
43					new IfNullExpression(targetReference, IfNull(emitter.ReturnType), IfNotNull(targetReference))));
44			return emitter;
45		}
46
47		private Expression IfNotNull(Reference targetReference)
48		{
49			var expression = new MultiStatementExpression();
50			var arguments = ArgumentsUtil.ConvertToArgumentReferenceExpression(MethodToOverride.GetParameters());
51
52			expression.AddStatement(new ReturnStatement(
53			                        	new MethodInvocationExpression(
54			                        		targetReference,
55			                        		MethodToOverride,
56			                        		arguments) { VirtualCall = true }));
57			return expression;
58		}
59
60		private Expression IfNull(Type returnType)
61		{
62			var expression = new MultiStatementExpression();
63			InitOutParameters(expression, MethodToOverride.GetParameters());
64
65			if (returnType == typeof(void))
66			{
67				expression.AddStatement(new ReturnStatement());
68			}
69			else
70			{
71				expression.AddStatement(new ReturnStatement(new DefaultValueExpression(returnType)));
72			}
73			return expression;
74		}
75
76		private void InitOutParameters(MultiStatementExpression expression, ParameterInfo[] parameters)
77		{
78			for (var index = 0; index < parameters.Length; index++)
79			{
80				var parameter = parameters[index];
81				if (parameter.IsOut)
82				{
83					expression.AddStatement(
84						new AssignArgumentStatement(new ArgumentReference(parameter.ParameterType, index + 1, parameter.Attributes),
85						                            new DefaultValueExpression(parameter.ParameterType)));
86				}
87			}
88		}
89	}
90}

Source: OptionallyForwardingMethodGenerator.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.Contributors
{
	using System;
	using System.Reflection;

	using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;
	using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;
	using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;

	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;

		public OptionallyForwardingMethodGenerator(MetaMethod method, OverrideMethodDelegate overrideMethod,
		                                           GetTargetReferenceDelegate getTargetReference)
			: base(method, overrideMethod)
		{
			this.getTargetReference = getTargetReference;
		}

		protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class,
		                                                        ProxyGenerationOptions options, INamingScope namingScope)
		{
			var targetReference = getTargetReference(@class, MethodToOverride);

			emitter.CodeBuilder.AddStatement(
				new ExpressionStatement(
					new IfNullExpression(targetReference, IfNull(emitter.ReturnType), IfNotNull(targetReference))));
			return emitter;
		}

		private Expression IfNotNull(Reference targetReference)
		{
			var expression = new MultiStatementExpression();
			var arguments = ArgumentsUtil.ConvertToArgumentReferenceExpression(MethodToOverride.GetParameters());

			expression.AddStatement(new ReturnStatement(
			                        	new MethodInvocationExpression(
			                        		targetReference,
			                        		MethodToOverride,
			                        		arguments) { VirtualCall = true }));
			return expression;
		}

		private Expression IfNull(Type returnType)
		{
			var expression = new MultiStatementExpression();
			InitOutParameters(expression, MethodToOverride.GetParameters());

			if (returnType == typeof(void))
			{
				expression.AddStatement(new ReturnStatement());
			}
			else
			{
				expression.AddStatement(new ReturnStatement(new DefaultValueExpression(returnType)));
			}
			return expression;
		}

		private void InitOutParameters(MultiStatementExpression expression, ParameterInfo[] parameters)
		{
			for (var index = 0; index < parameters.Length; index++)
			{
				var parameter = parameters[index];
				if (parameter.IsOut)
				{
					expression.AddStatement(
						new AssignArgumentStatement(new ArgumentReference(parameter.ParameterType, index + 1, parameter.Attributes),
						                            new DefaultValueExpression(parameter.ParameterType)));
				}
			}
		}
	}
}

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.Collections.Generic;
18	using System.Reflection.Emit;
19
20	internal class MultiStatementExpression : Expression
21	{
22		private readonly List<Statement> statements = new List<Statement>();
23
24		public void AddStatement(Statement statement)
25		{
26			statements.Add(statement);
27		}
28
29		public void AddExpression(Expression expression)
30		{
31			AddStatement(new ExpressionStatement(expression));
32		}
33
34		public override void Emit(IMemberEmitter member, ILGenerator gen)
35		{
36			foreach (Statement s in statements)
37			{
38				s.Emit(member, gen);
39			}
40		}
41	}
42}

Source: MultiStatementExpression.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.Collections.Generic;
	using System.Reflection.Emit;

	internal class MultiStatementExpression : Expression
	{
		private readonly List<Statement> statements = new List<Statement>();

		public void AddStatement(Statement statement)
		{
			statements.Add(statement);
		}

		public void AddExpression(Expression expression)
		{
			AddStatement(new ExpressionStatement(expression));
		}

		public override void Emit(IMemberEmitter member, ILGenerator gen)
		{
			foreach (Statement s in statements)
			{
				s.Emit(member, gen);
			}
		}
	}
}