Fix Pascal / camel-casing of various identifiers

stakx · stakx · commit 02eefdb66548 · 2022-05-18T13:29:29.000+02:00
diff --git a/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ClassProxySerializableContributor.cs
@@ -89,10 +89,10 @@ protected override void AddAddValueInvocation(ArgumentReference serializationInf
 			base.AddAddValueInvocation(serializationInfo, getObjectData, field);
 		}
 
-		protected override void CustomizeGetObjectData(CodeBuilder codebuilder, ArgumentReference serializationInfo,
+		protected override void CustomizeGetObjectData(CodeBuilder codeBuilder, ArgumentReference serializationInfo,
 		                                               ArgumentReference streamingContext, ClassEmitter emitter)
 		{
-			codebuilder.AddStatement(
+			codeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					serializationInfo,
 					SerializationInfoMethods.AddValue_Bool,
@@ -101,53 +101,53 @@ protected override void CustomizeGetObjectData(CodeBuilder codebuilder, Argument
 
 			if (delegateToBaseGetObjectData == false)
 			{
-				EmitCustomGetObjectData(codebuilder, serializationInfo);
+				EmitCustomGetObjectData(codeBuilder, serializationInfo);
 				return;
 			}
 
-			EmitCallToBaseGetObjectData(codebuilder, serializationInfo, streamingContext);
+			EmitCallToBaseGetObjectData(codeBuilder, serializationInfo, streamingContext);
 		}
 
-		private void EmitCustomGetObjectData(CodeBuilder codebuilder, ArgumentReference serializationInfo)
+		private void EmitCustomGetObjectData(CodeBuilder codeBuilder, ArgumentReference serializationInfo)
 		{
-			var members = codebuilder.DeclareLocal(typeof(MemberInfo[]));
-			var data = codebuilder.DeclareLocal(typeof(object[]));
+			var members = codeBuilder.DeclareLocal(typeof(MemberInfo[]));
+			var data = codeBuilder.DeclareLocal(typeof(object[]));
 
 			var getSerializableMembers = new MethodInvocationExpression(
 				null,
 				FormatterServicesMethods.GetSerializableMembers,
 				new TypeTokenExpression(targetType));
-			codebuilder.AddStatement(new AssignStatement(members, getSerializableMembers));
+			codeBuilder.AddStatement(new AssignStatement(members, getSerializableMembers));
 
 			// Sort to keep order on both serialize and deserialize side the same, c.f DYNPROXY-ISSUE-127
 			var callSort = new MethodInvocationExpression(
 				null,
 				TypeUtilMethods.Sort,
 				members);
-			codebuilder.AddStatement(new AssignStatement(members, callSort));
+			codeBuilder.AddStatement(new AssignStatement(members, callSort));
 
 			var getObjectData = new MethodInvocationExpression(
 				null,
 				FormatterServicesMethods.GetObjectData,
 				SelfReference.Self,
 				members);
-			codebuilder.AddStatement(new AssignStatement(data, getObjectData));
+			codeBuilder.AddStatement(new AssignStatement(data, getObjectData));
 
 			var addValue = new MethodInvocationExpression(
 				serializationInfo,
 				SerializationInfoMethods.AddValue_Object,
 				new LiteralStringExpression("__data"),
 				data);
-			codebuilder.AddStatement(addValue);
+			codeBuilder.AddStatement(addValue);
 		}
 
-		private void EmitCallToBaseGetObjectData(CodeBuilder codebuilder, ArgumentReference serializationInfo,
+		private void EmitCallToBaseGetObjectData(CodeBuilder codeBuilder, ArgumentReference serializationInfo,
 		                                         ArgumentReference streamingContext)
 		{
 			var baseGetObjectData = targetType.GetMethod("GetObjectData",
 			                                             new[] { typeof(SerializationInfo), typeof(StreamingContext) });
 
-			codebuilder.AddStatement(
+			codeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					baseGetObjectData,
 					serializationInfo,
diff --git a/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxySerializableContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/InterfaceProxySerializableContributor.cs
@@ -29,19 +29,19 @@ public InterfaceProxySerializableContributor(Type targetType, string proxyGenera
 		{
 		}
 
-		protected override void CustomizeGetObjectData(CodeBuilder codebuilder, ArgumentReference serializationInfo,
+		protected override void CustomizeGetObjectData(CodeBuilder codeBuilder, ArgumentReference serializationInfo,
 		                                               ArgumentReference streamingContext, ClassEmitter emitter)
 		{
 			var targetField = emitter.GetField("__target");
 
-			codebuilder.AddStatement(
+			codeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					serializationInfo,
 					SerializationInfoMethods.AddValue_Object,
 					new LiteralStringExpression("__targetFieldType"),
 					new LiteralStringExpression(targetField.Reference.FieldType.AssemblyQualifiedName)));
 
-			codebuilder.AddStatement(
+			codeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					serializationInfo,
 					SerializationInfoMethods.AddValue_Object,
diff --git a/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs b/src/Castle.Core/DynamicProxy/Contributors/ProxyTargetAccessorContributor.cs
@@ -55,7 +55,7 @@ public void Generate(ClassEmitter emitter)
 			{
 				dynProxySetTarget.CodeBuilder.AddStatement(
 					new AssignStatement(targetField,
-						new ConvertExpression(targetField.Fieldbuilder.FieldType, dynProxySetTarget.Arguments[0])));
+						new ConvertExpression(targetField.FieldBuilder.FieldType, dynProxySetTarget.Arguments[0])));
 			}
 			else
 			{
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/AbstractTypeEmitter.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/AbstractTypeEmitter.cs
@@ -38,13 +38,13 @@ internal abstract class AbstractTypeEmitter
 
 		private readonly List<NestedClassEmitter> nested;
 		private readonly List<PropertyEmitter> properties;
-		private readonly TypeBuilder typebuilder;
+		private readonly TypeBuilder typeBuilder;
 
 		private GenericTypeParameterBuilder[] genericTypeParams;
 
 		protected AbstractTypeEmitter(TypeBuilder typeBuilder)
 		{
-			typebuilder = typeBuilder;
+			this.typeBuilder = typeBuilder;
 			nested = new List<NestedClassEmitter>();
 			methods = new List<MethodEmitter>();
 			constructors = new List<ConstructorEmitter>();
@@ -73,14 +73,14 @@ public GenericTypeParameterBuilder[] GenericTypeParams
 
 		public TypeBuilder TypeBuilder
 		{
-			get { return typebuilder; }
+			get { return typeBuilder; }
 		}
 
 		public void AddCustomAttributes(IEnumerable<CustomAttributeInfo> additionalAttributes)
 		{
 			foreach (var attribute in additionalAttributes)
 			{
-				typebuilder.SetCustomAttribute(attribute.Builder);
+				typeBuilder.SetCustomAttribute(attribute.Builder);
 			}
 		}
 
@@ -93,7 +93,7 @@ public virtual Type BuildType()
 		{
 			EnsureBuildersAreInAValidState();
 
-			var type = CreateType(typebuilder);
+			var type = CreateType(typeBuilder);
 
 			foreach (var builder in nested)
 			{
@@ -111,7 +111,7 @@ public void CopyGenericParametersFromMethod(MethodInfo methodToCopyGenericsFrom)
 				throw new InvalidOperationException("Cannot invoke me twice");
 			}
 
-			SetGenericTypeParameters(GenericUtil.CopyGenericArguments(methodToCopyGenericsFrom, typebuilder));
+			SetGenericTypeParameters(GenericUtil.CopyGenericArguments(methodToCopyGenericsFrom, typeBuilder));
 		}
 
 		public ConstructorEmitter CreateConstructor(params ArgumentReference[] arguments)
@@ -162,7 +162,7 @@ public FieldReference CreateField(string name, Type fieldType, bool serializable
 
 		public FieldReference CreateField(string name, Type fieldType, FieldAttributes atts)
 		{
-			var fieldBuilder = typebuilder.DefineField(name, fieldType, atts);
+			var fieldBuilder = typeBuilder.DefineField(name, fieldType, atts);
 			var reference = new FieldReference(fieldBuilder);
 			fields[name] = reference;
 			return reference;
@@ -220,31 +220,31 @@ public ConstructorEmitter CreateTypeConstructor()
 
 		public void DefineCustomAttribute(CustomAttributeBuilder attribute)
 		{
-			typebuilder.SetCustomAttribute(attribute);
+			typeBuilder.SetCustomAttribute(attribute);
 		}
 
 		public void DefineCustomAttribute<TAttribute>(object[] constructorArguments) where TAttribute : Attribute
 		{
 			var customAttributeInfo = AttributeUtil.CreateInfo(typeof(TAttribute), constructorArguments);
-			typebuilder.SetCustomAttribute(customAttributeInfo.Builder);
+			typeBuilder.SetCustomAttribute(customAttributeInfo.Builder);
 		}
 
 		public void DefineCustomAttribute<TAttribute>() where TAttribute : Attribute, new()
 		{
 			var customAttributeInfo = AttributeUtil.CreateInfo<TAttribute>();
-			typebuilder.SetCustomAttribute(customAttributeInfo.Builder);
+			typeBuilder.SetCustomAttribute(customAttributeInfo.Builder);
 		}
 
 		public void DefineCustomAttributeFor<TAttribute>(FieldReference field) where TAttribute : Attribute, new()
 		{
 			var customAttributeInfo = AttributeUtil.CreateInfo<TAttribute>();
-			var fieldbuilder = field.Fieldbuilder;
-			if (fieldbuilder == null)
+			var fieldBuilder = field.FieldBuilder;
+			if (fieldBuilder == null)
 			{
 				throw new ArgumentException(
 					"Invalid field reference.This reference does not point to field on type being generated", nameof(field));
 			}
-			fieldbuilder.SetCustomAttribute(customAttributeInfo.Builder);
+			fieldBuilder.SetCustomAttribute(customAttributeInfo.Builder);
 		}
 
 		public IEnumerable<FieldReference> GetAllFields()
@@ -344,7 +344,7 @@ protected Type CreateType(TypeBuilder type)
 
 		protected virtual void EnsureBuildersAreInAValidState()
 		{
-			if (!typebuilder.IsInterface && constructors.Count == 0)
+			if (!typeBuilder.IsInterface && constructors.Count == 0)
 			{
 				CreateDefaultConstructor();
 			}
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/ClassEmitter.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/ClassEmitter.cs
@@ -29,15 +29,15 @@ internal class ClassEmitter : AbstractTypeEmitter
 
 		private readonly ModuleScope moduleScope;
 
-		public ClassEmitter(ModuleScope modulescope, string name, Type baseType, IEnumerable<Type> interfaces)
-			: this(modulescope, name, baseType, interfaces, DefaultAttributes, forceUnsigned: false)
+		public ClassEmitter(ModuleScope moduleScope, string name, Type baseType, IEnumerable<Type> interfaces)
+			: this(moduleScope, name, baseType, interfaces, DefaultAttributes, forceUnsigned: false)
 		{
 		}
 
-		public ClassEmitter(ModuleScope modulescope, string name, Type baseType, IEnumerable<Type> interfaces,
+		public ClassEmitter(ModuleScope moduleScope, string name, Type baseType, IEnumerable<Type> interfaces,
 		                    TypeAttributes flags,
 		                    bool forceUnsigned)
-			: this(CreateTypeBuilder(modulescope, name, baseType, interfaces, flags, forceUnsigned))
+			: this(CreateTypeBuilder(moduleScope, name, baseType, interfaces, flags, forceUnsigned))
 		{
 			interfaces = InitializeGenericArgumentsFromBases(ref baseType, interfaces);
 
@@ -57,7 +57,7 @@ public ClassEmitter(ModuleScope modulescope, string name, Type baseType, IEnumer
 			}
 
 			TypeBuilder.SetParent(baseType);
-			moduleScope = modulescope;
+			this.moduleScope = moduleScope;
 		}
 
 		public ClassEmitter(TypeBuilder typeBuilder)
@@ -98,12 +98,12 @@ protected virtual IEnumerable<Type> InitializeGenericArgumentsFromBases(ref Type
 			return interfaces;
 		}
 
-		private static TypeBuilder CreateTypeBuilder(ModuleScope modulescope, string name, Type baseType,
+		private static TypeBuilder CreateTypeBuilder(ModuleScope moduleScope, string name, Type baseType,
 		                                             IEnumerable<Type> interfaces,
 		                                             TypeAttributes flags, bool forceUnsigned)
 		{
 			var isAssemblySigned = !forceUnsigned && !StrongNameUtil.IsAnyTypeFromUnsignedAssembly(baseType, interfaces);
-			return modulescope.DefineType(isAssemblySigned, name, flags);
+			return moduleScope.DefineType(isAssemblySigned, name, flags);
 		}
 	}
 }
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/ConstructorEmitter.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/ConstructorEmitter.cs
@@ -24,22 +24,22 @@ internal class ConstructorEmitter : IMemberEmitter
 	{
 		private readonly ConstructorBuilder builder;
 		private readonly CodeBuilder codeBuilder;
-		private readonly AbstractTypeEmitter maintype;
+		private readonly AbstractTypeEmitter mainType;
 
-		protected internal ConstructorEmitter(AbstractTypeEmitter maintype, ConstructorBuilder builder)
+		protected internal ConstructorEmitter(AbstractTypeEmitter mainType, ConstructorBuilder builder)
 		{
-			this.maintype = maintype;
+			this.mainType = mainType;
 			this.builder = builder;
 			codeBuilder = new CodeBuilder();
 		}
 
-		internal ConstructorEmitter(AbstractTypeEmitter maintype, params ArgumentReference[] arguments)
+		internal ConstructorEmitter(AbstractTypeEmitter mainType, params ArgumentReference[] arguments)
 		{
-			this.maintype = maintype;
+			this.mainType = mainType;
 
 			var args = ArgumentsUtil.InitializeAndConvert(arguments);
 
-			builder = maintype.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, args);
+			builder = mainType.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, args);
 			codeBuilder = new CodeBuilder();
 		}
 
@@ -76,7 +76,7 @@ public virtual void EnsureValidCodeBlock()
 		{
 			if (ImplementedByRuntime == false && CodeBuilder.IsEmpty)
 			{
-				CodeBuilder.AddStatement(new ConstructorInvocationStatement(maintype.BaseType));
+				CodeBuilder.AddStatement(new ConstructorInvocationStatement(mainType.BaseType));
 				CodeBuilder.AddStatement(new ReturnStatement());
 			}
 		}
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/NestedClassEmitter.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/NestedClassEmitter.cs
@@ -20,30 +20,30 @@ namespace Castle.DynamicProxy.Generators.Emitters
 
 	internal class NestedClassEmitter : AbstractTypeEmitter
 	{
-		public NestedClassEmitter(AbstractTypeEmitter maintype, string name, Type baseType, Type[] interfaces)
+		public NestedClassEmitter(AbstractTypeEmitter mainType, string name, Type baseType, Type[] interfaces)
 			: this(
-				maintype,
-				CreateTypeBuilder(maintype, name, TypeAttributes.Sealed | TypeAttributes.NestedPublic | TypeAttributes.Class,
+				mainType,
+				CreateTypeBuilder(mainType, name, TypeAttributes.Sealed | TypeAttributes.NestedPublic | TypeAttributes.Class,
 				                  baseType, interfaces))
 		{
 		}
 
-		public NestedClassEmitter(AbstractTypeEmitter maintype, string name, TypeAttributes attributes, Type baseType,
+		public NestedClassEmitter(AbstractTypeEmitter mainType, string name, TypeAttributes attributes, Type baseType,
 		                          Type[] interfaces)
-			: this(maintype, CreateTypeBuilder(maintype, name, attributes, baseType, interfaces))
+			: this(mainType, CreateTypeBuilder(mainType, name, attributes, baseType, interfaces))
 		{
 		}
 
-		public NestedClassEmitter(AbstractTypeEmitter maintype, TypeBuilder typeBuilder)
+		public NestedClassEmitter(AbstractTypeEmitter mainType, TypeBuilder typeBuilder)
 			: base(typeBuilder)
 		{
-			maintype.AddNestedClass(this);
+			mainType.AddNestedClass(this);
 		}
 
-		private static TypeBuilder CreateTypeBuilder(AbstractTypeEmitter maintype, string name, TypeAttributes attributes,
+		private static TypeBuilder CreateTypeBuilder(AbstractTypeEmitter mainType, string name, TypeAttributes attributes,
 		                                             Type baseType, Type[] interfaces)
 		{
-			return maintype.TypeBuilder.DefineNestedType(
+			return mainType.TypeBuilder.DefineNestedType(
 				name,
 				attributes,
 				baseType, interfaces);
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/FieldReference.cs
@@ -18,11 +18,11 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	using System.Reflection;
 	using System.Reflection.Emit;
 
-	[DebuggerDisplay("{fieldbuilder.Name} ({fieldbuilder.FieldType})")]
+	[DebuggerDisplay("{fieldBuilder.Name} ({fieldBuilder.FieldType})")]
 	internal class FieldReference : Reference
 	{
 		private readonly FieldInfo field;
-		private readonly FieldBuilder fieldbuilder;
+		private readonly FieldBuilder fieldBuilder;
 		private readonly bool isStatic;
 
 		public FieldReference(FieldInfo field)
@@ -35,20 +35,20 @@ public FieldReference(FieldInfo field)
 			}
 		}
 
-		public FieldReference(FieldBuilder fieldbuilder)
+		public FieldReference(FieldBuilder fieldBuilder)
 		{
-			this.fieldbuilder = fieldbuilder;
-			field = fieldbuilder;
-			if ((fieldbuilder.Attributes & FieldAttributes.Static) != 0)
+			this.fieldBuilder = fieldBuilder;
+			field = fieldBuilder;
+			if ((fieldBuilder.Attributes & FieldAttributes.Static) != 0)
 			{
 				isStatic = true;
 				owner = null;
 			}
 		}
 
-		public FieldBuilder Fieldbuilder
+		public FieldBuilder FieldBuilder
 		{
-			get { return fieldbuilder; }
+			get { return fieldBuilder; }
 		}
 
 		public FieldInfo Reference
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LocalReference.cs
diff --git a/src/Castle.Core/DynamicProxy/Generators/Emitters/TypeConstructorEmitter.cs b/src/Castle.Core/DynamicProxy/Generators/Emitters/TypeConstructorEmitter.cs

Original file line number	Diff line number	Diff line change
`@@ -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])));`
	`58`	`+ new ConvertExpression(targetField.FieldBuilder.FieldType, dynProxySetTarget.Arguments[0])));`
`59`	`59`	`}`
`60`	`60`	`else`
`61`	`61`	`{`
Original file line number	Diff line number	Diff line change
`@@ -38,13 +38,13 @@ internal abstract class AbstractTypeEmitter`
`38`	`38`
`39`	`39`	`private readonly List<NestedClassEmitter> nested;`
`40`	`40`	`private readonly List<PropertyEmitter> properties;`
`41`		`- private readonly TypeBuilder typebuilder;`
	`41`	`+ private readonly TypeBuilder typeBuilder;`
`42`	`42`
`43`	`43`	`private GenericTypeParameterBuilder[] genericTypeParams;`
`44`	`44`
`45`	`45`	`protected AbstractTypeEmitter(TypeBuilder typeBuilder)`
`46`	`46`	`{`
`47`		`- typebuilder = typeBuilder;`
	`47`	`+ this.typeBuilder = typeBuilder;`
`48`	`48`	`nested = new List<NestedClassEmitter>();`
`49`	`49`	`methods = new List<MethodEmitter>();`
`50`	`50`	`constructors = new List<ConstructorEmitter>();`
`@@ -73,14 +73,14 @@ public GenericTypeParameterBuilder[] GenericTypeParams`
`73`	`73`
`74`	`74`	`public TypeBuilder TypeBuilder`
`75`	`75`	`{`
`76`		`- get { return typebuilder; }`
	`76`	`+ get { return typeBuilder; }`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`public void AddCustomAttributes(IEnumerable<CustomAttributeInfo> additionalAttributes)`
`80`	`80`	`{`
`81`	`81`	`foreach (var attribute in additionalAttributes)`
`82`	`82`	`{`
`83`		`- typebuilder.SetCustomAttribute(attribute.Builder);`
	`83`	`+ typeBuilder.SetCustomAttribute(attribute.Builder);`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`@@ -93,7 +93,7 @@ public virtual Type BuildType()`
`93`	`93`	`{`
`94`	`94`	`EnsureBuildersAreInAValidState();`
`95`	`95`
`96`		`- var type = CreateType(typebuilder);`
	`96`	`+ var type = CreateType(typeBuilder);`
`97`	`97`
`98`	`98`	`foreach (var builder in nested)`
`99`	`99`	`{`
`@@ -111,7 +111,7 @@ public void CopyGenericParametersFromMethod(MethodInfo methodToCopyGenericsFrom)`
`111`	`111`	`throw new InvalidOperationException("Cannot invoke me twice");`
`112`	`112`	`}`
`113`	`113`
`114`		`- SetGenericTypeParameters(GenericUtil.CopyGenericArguments(methodToCopyGenericsFrom, typebuilder));`
	`114`	`+ SetGenericTypeParameters(GenericUtil.CopyGenericArguments(methodToCopyGenericsFrom, typeBuilder));`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`public ConstructorEmitter CreateConstructor(params ArgumentReference[] arguments)`
`@@ -162,7 +162,7 @@ public FieldReference CreateField(string name, Type fieldType, bool serializable`
`162`	`162`
`163`	`163`	`public FieldReference CreateField(string name, Type fieldType, FieldAttributes atts)`
`164`	`164`	`{`
`165`		`- var fieldBuilder = typebuilder.DefineField(name, fieldType, atts);`
	`165`	`+ var fieldBuilder = typeBuilder.DefineField(name, fieldType, atts);`
`166`	`166`	`var reference = new FieldReference(fieldBuilder);`
`167`	`167`	`fields[name] = reference;`
`168`	`168`	`return reference;`
`@@ -220,31 +220,31 @@ public ConstructorEmitter CreateTypeConstructor()`
`220`	`220`
`221`	`221`	`public void DefineCustomAttribute(CustomAttributeBuilder attribute)`
`222`	`222`	`{`
`223`		`- typebuilder.SetCustomAttribute(attribute);`
	`223`	`+ typeBuilder.SetCustomAttribute(attribute);`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`public void DefineCustomAttribute<TAttribute>(object[] constructorArguments) where TAttribute : Attribute`
`227`	`227`	`{`
`228`	`228`	`var customAttributeInfo = AttributeUtil.CreateInfo(typeof(TAttribute), constructorArguments);`
`229`		`- typebuilder.SetCustomAttribute(customAttributeInfo.Builder);`
	`229`	`+ typeBuilder.SetCustomAttribute(customAttributeInfo.Builder);`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`public void DefineCustomAttribute<TAttribute>() where TAttribute : Attribute, new()`
`233`	`233`	`{`
`234`	`234`	`var customAttributeInfo = AttributeUtil.CreateInfo<TAttribute>();`
`235`		`- typebuilder.SetCustomAttribute(customAttributeInfo.Builder);`
	`235`	`+ typeBuilder.SetCustomAttribute(customAttributeInfo.Builder);`
`236`	`236`	`}`
`237`	`237`
`238`	`238`	`public void DefineCustomAttributeFor<TAttribute>(FieldReference field) where TAttribute : Attribute, new()`
`239`	`239`	`{`
`240`	`240`	`var customAttributeInfo = AttributeUtil.CreateInfo<TAttribute>();`
`241`		`- var fieldbuilder = field.Fieldbuilder;`
`242`		`- if (fieldbuilder == null)`
	`241`	`+ var fieldBuilder = field.FieldBuilder;`
	`242`	`+ if (fieldBuilder == null)`
`243`	`243`	`{`
`244`	`244`	`throw new ArgumentException(`
`245`	`245`	`"Invalid field reference.This reference does not point to field on type being generated", nameof(field));`
`246`	`246`	`}`
`247`		`- fieldbuilder.SetCustomAttribute(customAttributeInfo.Builder);`
	`247`	`+ fieldBuilder.SetCustomAttribute(customAttributeInfo.Builder);`
`248`	`248`	`}`
`249`	`249`
`250`	`250`	`public IEnumerable<FieldReference> GetAllFields()`
`@@ -344,7 +344,7 @@ protected Type CreateType(TypeBuilder type)`
`344`	`344`
`345`	`345`	`protected virtual void EnsureBuildersAreInAValidState()`
`346`	`346`	`{`
`347`		`- if (!typebuilder.IsInterface && constructors.Count == 0)`
	`347`	`+ if (!typeBuilder.IsInterface && constructors.Count == 0)`
`348`	`348`	`{`
`349`	`349`	`CreateDefaultConstructor();`
`350`	`350`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,15 +29,15 @@ internal class ClassEmitter : AbstractTypeEmitter`
`29`	`29`
`30`	`30`	`private readonly ModuleScope moduleScope;`
`31`	`31`
`32`		`- public ClassEmitter(ModuleScope modulescope, string name, Type baseType, IEnumerable<Type> interfaces)`
`33`		`- : this(modulescope, name, baseType, interfaces, DefaultAttributes, forceUnsigned: false)`
	`32`	`+ public ClassEmitter(ModuleScope moduleScope, string name, Type baseType, IEnumerable<Type> interfaces)`
	`33`	`+ : this(moduleScope, name, baseType, interfaces, DefaultAttributes, forceUnsigned: false)`
`34`	`34`	`{`
`35`	`35`	`}`
`36`	`36`
`37`		`- public ClassEmitter(ModuleScope modulescope, string name, Type baseType, IEnumerable<Type> interfaces,`
	`37`	`+ public ClassEmitter(ModuleScope moduleScope, string name, Type baseType, IEnumerable<Type> interfaces,`
`38`	`38`	`TypeAttributes flags,`
`39`	`39`	`bool forceUnsigned)`
`40`		`- : this(CreateTypeBuilder(modulescope, name, baseType, interfaces, flags, forceUnsigned))`
	`40`	`+ : this(CreateTypeBuilder(moduleScope, name, baseType, interfaces, flags, forceUnsigned))`
`41`	`41`	`{`
`42`	`42`	`interfaces = InitializeGenericArgumentsFromBases(ref baseType, interfaces);`
`43`	`43`
`@@ -57,7 +57,7 @@ public ClassEmitter(ModuleScope modulescope, string name, Type baseType, IEnumer`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`TypeBuilder.SetParent(baseType);`
`60`		`- moduleScope = modulescope;`
	`60`	`+ this.moduleScope = moduleScope;`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`public ClassEmitter(TypeBuilder typeBuilder)`
`@@ -98,12 +98,12 @@ protected virtual IEnumerable<Type> InitializeGenericArgumentsFromBases(ref Type`
`98`	`98`	`return interfaces;`
`99`	`99`	`}`
`100`	`100`
`101`		`- private static TypeBuilder CreateTypeBuilder(ModuleScope modulescope, string name, Type baseType,`
	`101`	`+ private static TypeBuilder CreateTypeBuilder(ModuleScope moduleScope, string name, Type baseType,`
`102`	`102`	`IEnumerable<Type> interfaces,`
`103`	`103`	`TypeAttributes flags, bool forceUnsigned)`
`104`	`104`	`{`
`105`	`105`	`var isAssemblySigned = !forceUnsigned && !StrongNameUtil.IsAnyTypeFromUnsignedAssembly(baseType, interfaces);`
`106`		`- return modulescope.DefineType(isAssemblySigned, name, flags);`
	`106`	`+ return moduleScope.DefineType(isAssemblySigned, name, flags);`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,22 +24,22 @@ internal class ConstructorEmitter : IMemberEmitter`
`24`	`24`	`{`
`25`	`25`	`private readonly ConstructorBuilder builder;`
`26`	`26`	`private readonly CodeBuilder codeBuilder;`
`27`		`- private readonly AbstractTypeEmitter maintype;`
	`27`	`+ private readonly AbstractTypeEmitter mainType;`
`28`	`28`
`29`		`- protected internal ConstructorEmitter(AbstractTypeEmitter maintype, ConstructorBuilder builder)`
	`29`	`+ protected internal ConstructorEmitter(AbstractTypeEmitter mainType, ConstructorBuilder builder)`
`30`	`30`	`{`
`31`		`- this.maintype = maintype;`
	`31`	`+ this.mainType = mainType;`
`32`	`32`	`this.builder = builder;`
`33`	`33`	`codeBuilder = new CodeBuilder();`
`34`	`34`	`}`
`35`	`35`
`36`		`- internal ConstructorEmitter(AbstractTypeEmitter maintype, params ArgumentReference[] arguments)`
	`36`	`+ internal ConstructorEmitter(AbstractTypeEmitter mainType, params ArgumentReference[] arguments)`
`37`	`37`	`{`
`38`		`- this.maintype = maintype;`
	`38`	`+ this.mainType = mainType;`
`39`	`39`
`40`	`40`	`var args = ArgumentsUtil.InitializeAndConvert(arguments);`
`41`	`41`
`42`		`- builder = maintype.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, args);`
	`42`	`+ builder = mainType.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, args);`
`43`	`43`	`codeBuilder = new CodeBuilder();`
`44`	`44`	`}`
`45`	`45`
`@@ -76,7 +76,7 @@ public virtual void EnsureValidCodeBlock()`
`76`	`76`	`{`
`77`	`77`	`if (ImplementedByRuntime == false && CodeBuilder.IsEmpty)`
`78`	`78`	`{`
`79`		`- CodeBuilder.AddStatement(new ConstructorInvocationStatement(maintype.BaseType));`
	`79`	`+ CodeBuilder.AddStatement(new ConstructorInvocationStatement(mainType.BaseType));`
`80`	`80`	`CodeBuilder.AddStatement(new ReturnStatement());`
`81`	`81`	`}`
`82`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,30 +20,30 @@ namespace Castle.DynamicProxy.Generators.Emitters`
`20`	`20`
`21`	`21`	`internal class NestedClassEmitter : AbstractTypeEmitter`
`22`	`22`	`{`
`23`		`- public NestedClassEmitter(AbstractTypeEmitter maintype, string name, Type baseType, Type[] interfaces)`
	`23`	`+ public NestedClassEmitter(AbstractTypeEmitter mainType, string name, Type baseType, Type[] interfaces)`
`24`	`24`	`: this(`
`25`		`- maintype,`
`26`		`- CreateTypeBuilder(maintype, name, TypeAttributes.Sealed \| TypeAttributes.NestedPublic \| TypeAttributes.Class,`
	`25`	`+ mainType,`
	`26`	`+ CreateTypeBuilder(mainType, name, TypeAttributes.Sealed \| TypeAttributes.NestedPublic \| TypeAttributes.Class,`
`27`	`27`	`baseType, interfaces))`
`28`	`28`	`{`
`29`	`29`	`}`
`30`	`30`
`31`		`- public NestedClassEmitter(AbstractTypeEmitter maintype, string name, TypeAttributes attributes, Type baseType,`
	`31`	`+ public NestedClassEmitter(AbstractTypeEmitter mainType, string name, TypeAttributes attributes, Type baseType,`
`32`	`32`	`Type[] interfaces)`
`33`		`- : this(maintype, CreateTypeBuilder(maintype, name, attributes, baseType, interfaces))`
	`33`	`+ : this(mainType, CreateTypeBuilder(mainType, name, attributes, baseType, interfaces))`
`34`	`34`	`{`
`35`	`35`	`}`
`36`	`36`
`37`		`- public NestedClassEmitter(AbstractTypeEmitter maintype, TypeBuilder typeBuilder)`
	`37`	`+ public NestedClassEmitter(AbstractTypeEmitter mainType, TypeBuilder typeBuilder)`
`38`	`38`	`: base(typeBuilder)`
`39`	`39`	`{`
`40`		`- maintype.AddNestedClass(this);`
	`40`	`+ mainType.AddNestedClass(this);`
`41`	`41`	`}`
`42`	`42`
`43`		`- private static TypeBuilder CreateTypeBuilder(AbstractTypeEmitter maintype, string name, TypeAttributes attributes,`
	`43`	`+ private static TypeBuilder CreateTypeBuilder(AbstractTypeEmitter mainType, string name, TypeAttributes attributes,`
`44`	`44`	`Type baseType, Type[] interfaces)`
`45`	`45`	`{`
`46`		`- return maintype.TypeBuilder.DefineNestedType(`
	`46`	`+ return mainType.TypeBuilder.DefineNestedType(`
`47`	`47`	`name,`
`48`	`48`	`attributes,`
`49`	`49`	`baseType, interfaces);`
Original file line number	Diff line number	Diff line change
`@@ -18,11 +18,11 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST`
`18`	`18`	`using System.Reflection;`
`19`	`19`	`using System.Reflection.Emit;`
`20`	`20`
`21`		`- [DebuggerDisplay("{fieldbuilder.Name} ({fieldbuilder.FieldType})")]`
	`21`	`+ [DebuggerDisplay("{fieldBuilder.Name} ({fieldBuilder.FieldType})")]`
`22`	`22`	`internal class FieldReference : Reference`
`23`	`23`	`{`
`24`	`24`	`private readonly FieldInfo field;`
`25`		`- private readonly FieldBuilder fieldbuilder;`
	`25`	`+ private readonly FieldBuilder fieldBuilder;`
`26`	`26`	`private readonly bool isStatic;`
`27`	`27`
`28`	`28`	`public FieldReference(FieldInfo field)`
`@@ -35,20 +35,20 @@ public FieldReference(FieldInfo field)`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
`38`		`- public FieldReference(FieldBuilder fieldbuilder)`
	`38`	`+ public FieldReference(FieldBuilder fieldBuilder)`
`39`	`39`	`{`
`40`		`- this.fieldbuilder = fieldbuilder;`
`41`		`- field = fieldbuilder;`
`42`		`- if ((fieldbuilder.Attributes & FieldAttributes.Static) != 0)`
	`40`	`+ this.fieldBuilder = fieldBuilder;`
	`41`	`+ field = fieldBuilder;`
	`42`	`+ if ((fieldBuilder.Attributes & FieldAttributes.Static) != 0)`
`43`	`43`	`{`
`44`	`44`	`isStatic = true;`
`45`	`45`	`owner = null;`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`49`		`- public FieldBuilder Fieldbuilder`
	`49`	`+ public FieldBuilder FieldBuilder`
`50`	`50`	`{`
`51`		`- get { return fieldbuilder; }`
	`51`	`+ get { return fieldBuilder; }`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`public FieldInfo Reference`