Merge pull request #565 from stakx/dp/refactor/code-builders

Replace all code builder classes with a single `CodeBuilder`

src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs

@@ -25,7 +25,6 @@ namespace Castle.DynamicProxy.Contributors
 
 	using Castle.DynamicProxy.Generators;
 	using Castle.DynamicProxy.Generators.Emitters;
-	using Castle.DynamicProxy.Generators.Emitters.CodeBuilders;
 	using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
 	using Castle.DynamicProxy.Internal;
 	using Castle.DynamicProxy.Tokens;
@@ -90,7 +89,7 @@ public override void Generate(ClassEmitter @class)
 			base.AddAddValueInvocation(serializationInfo, getObjectData, field);
 		}
 
-		protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference serializationInfo,
+		protected override void CustomizeGetObjectData(CodeBuilder codebuilder, ArgumentReference serializationInfo,
 		                                               ArgumentReference streamingContext, ClassEmitter emitter)
 		{
 			codebuilder.AddStatement(new ExpressionStatement(
@@ -110,7 +109,7 @@ public override void Generate(ClassEmitter @class)
 			EmitCallToBaseGetObjectData(codebuilder, serializationInfo, streamingContext);
 		}
 
-		private void EmitCustomGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference serializationInfo)
+		private void EmitCustomGetObjectData(CodeBuilder codebuilder, ArgumentReference serializationInfo)
 		{
 			var members = codebuilder.DeclareLocal(typeof(MemberInfo[]));
 			var data = codebuilder.DeclareLocal(typeof(object[]));
@@ -143,7 +142,7 @@ private void EmitCustomGetObjectData(AbstractCodeBuilder codebuilder, ArgumentRe
 			codebuilder.AddStatement(new ExpressionStatement(addValue));
 		}
 
-		private void EmitCallToBaseGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference serializationInfo,
+		private void EmitCallToBaseGetObjectData(CodeBuilder codebuilder, ArgumentReference serializationInfo,
 		                                         ArgumentReference streamingContext)
 		{
 			var baseGetObjectData = targetType.GetMethod("GetObjectData",

src/Castle.Core/DynamicProxy/Contributors/InterfaceProxySerializableContributor.cs

@@ -19,7 +19,6 @@ namespace Castle.DynamicProxy.Contributors
 	using System;
 
 	using Castle.DynamicProxy.Generators.Emitters;
-	using Castle.DynamicProxy.Generators.Emitters.CodeBuilders;
 	using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
 	using Castle.DynamicProxy.Tokens;
 
@@ -30,7 +29,7 @@ public InterfaceProxySerializableContributor(Type targetType, string proxyGenera
 		{
 		}
 
-		protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference serializationInfo,
+		protected override void CustomizeGetObjectData(CodeBuilder codebuilder, ArgumentReference serializationInfo,
 		                                               ArgumentReference streamingContext, ClassEmitter emitter)
 		{
 			var targetField = emitter.GetField("__target");

src/Castle.Core/DynamicProxy/Contributors/SerializableContributor.cs

@@ -21,7 +21,6 @@ namespace Castle.DynamicProxy.Contributors
 
 	using Castle.DynamicProxy.Generators;
 	using Castle.DynamicProxy.Generators.Emitters;
-	using Castle.DynamicProxy.Generators.Emitters.CodeBuilders;
 	using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
 	using Castle.DynamicProxy.Serialization;
 	using Castle.DynamicProxy.Tokens;
@@ -147,7 +146,7 @@ protected void ImplementGetObjectData(ClassEmitter emitter)
 			return;
 		}
 
-		protected abstract void CustomizeGetObjectData(AbstractCodeBuilder builder, ArgumentReference serializationInfo,
+		protected abstract void CustomizeGetObjectData(CodeBuilder builder, ArgumentReference serializationInfo,
 		                                               ArgumentReference streamingContext, ClassEmitter emitter);
 
 		public virtual void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model)

src/Castle.Core/DynamicProxy/Generators/BaseProxyGenerator.cs

@@ -27,7 +27,6 @@ namespace Castle.DynamicProxy.Generators
 	using Castle.Core.Logging;
 	using Castle.DynamicProxy.Contributors;
 	using Castle.DynamicProxy.Generators.Emitters;
-	using Castle.DynamicProxy.Generators.Emitters.CodeBuilders;
 	using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
 	using Castle.DynamicProxy.Internal;
 
@@ -155,7 +154,7 @@ protected void CheckNotGenericTypeDefinitions(IEnumerable<Type> types, string ar
 			}
 		}
 
-		protected void CompleteInitCacheMethod(ConstructorCodeBuilder constCodeBuilder)
+		protected void CompleteInitCacheMethod(CodeBuilder constCodeBuilder)
 		{
 			constCodeBuilder.AddStatement(new ReturnStatement());
 		}
@@ -275,11 +274,11 @@ protected void EnsureOptionsOverrideEqualsAndGetHashCode()
 				var slice = new ArgumentReference[baseConstructorParams.Length];
 				Array.Copy(args, fields.Length, slice, 0, baseConstructorParams.Length);
 
-				constructor.CodeBuilder.InvokeBaseConstructor(baseConstructor, slice);
+				constructor.CodeBuilder.AddStatement(new ConstructorInvocationStatement(baseConstructor, slice));
 			}
 			else
 			{
-				constructor.CodeBuilder.InvokeBaseConstructor();
+				constructor.CodeBuilder.AddStatement(new ConstructorInvocationStatement(emitter.BaseType));
 			}
 
 			constructor.CodeBuilder.AddStatement(new ReturnStatement());
@@ -336,7 +335,7 @@ protected void GenerateParameterlessConstructor(ClassEmitter emitter, Type baseC
 
 			// Invoke base constructor
 
-			constructor.CodeBuilder.InvokeBaseConstructor(defaultConstructor);
+			constructor.CodeBuilder.AddStatement(new ConstructorInvocationStatement(defaultConstructor));
 
 			constructor.CodeBuilder.AddStatement(new ReturnStatement());
 		}

src/Castle.Core/DynamicProxy/Generators/Emitters/CodeBuilders/AbstractCodeBuilder.cs → src/Castle.Core/DynamicProxy/Generators/Emitters/CodeBuilder.cs

@@ -12,74 +12,61 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-namespace Castle.DynamicProxy.Generators.Emitters.CodeBuilders
+namespace Castle.DynamicProxy.Generators.Emitters
 {
 	using System;
 	using System.Collections.Generic;
 	using System.Reflection.Emit;
 
 	using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
 
-	internal abstract class AbstractCodeBuilder
+	internal sealed class CodeBuilder
 	{
-		private readonly ILGenerator generator;
-		private readonly List<Reference> ilmarkers;
-		private readonly List<Statement> stmts;
+		private readonly List<LocalReference> locals;
+		private readonly List<Statement> statements;
 		private bool isEmpty;
 
-		protected AbstractCodeBuilder(ILGenerator generator)
+		public CodeBuilder()
 		{
-			this.generator = generator;
-			stmts = new List<Statement>();
-			ilmarkers = new List<Reference>();
+			statements = new List<Statement>();
+			locals = new List<LocalReference>();
 			isEmpty = true;
 		}
 
-		//NOTE: should we make this obsolete if no one is using it?
-		public /*protected internal*/ ILGenerator Generator
-		{
-			get { return generator; }
-		}
-
 		internal bool IsEmpty
 		{
 			get { return isEmpty; }
 		}
 
-		public AbstractCodeBuilder AddExpression(Expression expression)
+		public CodeBuilder AddExpression(Expression expression)
 		{
 			return AddStatement(new ExpressionStatement(expression));
 		}
 
-		public AbstractCodeBuilder AddStatement(Statement stmt)
+		public CodeBuilder AddStatement(Statement statement)
 		{
-			SetNonEmpty();
-			stmts.Add(stmt);
+			isEmpty = false;
+			statements.Add(statement);
 			return this;
 		}
 
 		public LocalReference DeclareLocal(Type type)
 		{
 			var local = new LocalReference(type);
-			ilmarkers.Add(local);
+			locals.Add(local);
 			return local;
 		}
 
-		public /*protected internal*/ void SetNonEmpty()
-		{
-			isEmpty = false;
-		}
-
 		internal void Generate(IMemberEmitter member, ILGenerator il)
 		{
-			foreach (var local in ilmarkers)
+			foreach (var local in locals)
 			{
 				local.Generate(il);
 			}
 
-			foreach (var stmt in stmts)
+			foreach (var statement in statements)
 			{
-				stmt.Emit(member, il);
+				statement.Emit(member, il);
 			}
 		}
 	}

src/Castle.Core/DynamicProxy/Generators/Emitters/ConstructorEmitter.cs

@@ -18,20 +18,19 @@ namespace Castle.DynamicProxy.Generators.Emitters
 	using System.Reflection;
 	using System.Reflection.Emit;
 
-	using Castle.DynamicProxy.Generators.Emitters.CodeBuilders;
 	using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
 
 	internal class ConstructorEmitter : IMemberEmitter
 	{
 		private readonly ConstructorBuilder builder;
+		private readonly CodeBuilder codeBuilder;
 		private readonly AbstractTypeEmitter maintype;
 
-		private ConstructorCodeBuilder constructorCodeBuilder;
-
 		protected internal ConstructorEmitter(AbstractTypeEmitter maintype, ConstructorBuilder builder)
 		{
 			this.maintype = maintype;
 			this.builder = builder;
+			codeBuilder = new CodeBuilder();
 		}
 
 		internal ConstructorEmitter(AbstractTypeEmitter maintype, params ArgumentReference[] arguments)
@@ -41,19 +40,12 @@ internal ConstructorEmitter(AbstractTypeEmitter maintype, params ArgumentReferen
 			var args = ArgumentsUtil.InitializeAndConvert(arguments);
 
 			builder = maintype.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, args);
+			codeBuilder = new CodeBuilder();
 		}
 
-		public virtual ConstructorCodeBuilder CodeBuilder
+		public CodeBuilder CodeBuilder
 		{
-			get
-			{
-				if (constructorCodeBuilder == null)
-				{
-					constructorCodeBuilder = new ConstructorCodeBuilder(
-						maintype.BaseType, builder.GetILGenerator());
-				}
-				return constructorCodeBuilder;
-			}
+			get { return codeBuilder; }
 		}
 
 		public ConstructorBuilder ConstructorBuilder
@@ -84,7 +76,7 @@ public virtual void EnsureValidCodeBlock()
 		{
 			if (ImplementedByRuntime == false && CodeBuilder.IsEmpty)
 			{
-				CodeBuilder.InvokeBaseConstructor();
+				CodeBuilder.AddStatement(new ConstructorInvocationStatement(maintype.BaseType));
 				CodeBuilder.AddStatement(new ReturnStatement());
 			}
 		}

src/Castle.Core/DynamicProxy/Generators/Emitters/MethodEmitter.cs

@@ -21,23 +21,22 @@ namespace Castle.DynamicProxy.Generators.Emitters
 	using System.Reflection;
 	using System.Reflection.Emit;
 
-	using Castle.DynamicProxy.Generators.Emitters.CodeBuilders;
 	using Castle.DynamicProxy.Generators.Emitters.SimpleAST;
 	using Castle.DynamicProxy.Internal;
 
 	[DebuggerDisplay("{builder.Name}")]
 	internal class MethodEmitter : IMemberEmitter
 	{
 		private readonly MethodBuilder builder;
+		private readonly CodeBuilder codeBuilder;
 		private readonly GenericTypeParameterBuilder[] genericTypeParams;
 
 		private ArgumentReference[] arguments;
 
-		private MethodCodeBuilder codebuilder;
-
 		protected internal MethodEmitter(MethodBuilder builder)
 		{
 			this.builder = builder;
+			codeBuilder = new CodeBuilder();
 		}
 
 		internal MethodEmitter(AbstractTypeEmitter owner, string name, MethodAttributes attributes)
@@ -76,16 +75,9 @@ public ArgumentReference[] Arguments
 			get { return arguments; }
 		}
 
-		public virtual MethodCodeBuilder CodeBuilder
+		public CodeBuilder CodeBuilder
 		{
-			get
-			{
-				if (codebuilder == null)
-				{
-					codebuilder = new MethodCodeBuilder(builder.GetILGenerator());
-				}
-				return codebuilder;
-			}
+			get { return codeBuilder; }
 		}
 
 		public GenericTypeParameterBuilder[] GenericTypeParams
@@ -145,7 +137,7 @@ public virtual void Generate()
 				return;
 			}
 
-			codebuilder.Generate(this, builder.GetILGenerator());
+			codeBuilder.Generate(this, builder.GetILGenerator());
 		}
 
 		private void DefineParameters(ParameterInfo[] parameters)