Merge pull request #583 from stakx/dp/refactor/simple-ast

Replace `ConstReference` with `Literal...Expression` node types

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"),
-					new ConstReference(delegateToBaseGetObjectData)));
+					new LiteralStringExpression("__delegateToBase"),
+					new LiteralBoolExpression(delegateToBaseGetObjectData)));
 
 			if (delegateToBaseGetObjectData == false)
 			{
@@ -136,7 +136,7 @@ private void EmitCustomGetObjectData(CodeBuilder codebuilder, ArgumentReference
 			var addValue = new MethodInvocationExpression(
 				serializationInfo,
 				SerializationInfoMethods.AddValue_Object,
-				new ConstReference("__data"),
+				new LiteralStringExpression("__data"),
 				data);
 			codebuilder.AddStatement(addValue);
 		}
@@ -179,7 +179,7 @@ private void GenerateSerializationConstructor(ClassEmitter emitter)
 			{
 				var getValue = new MethodInvocationExpression(serializationInfo,
 				                                              SerializationInfoMethods.GetValue,
-				                                              new ConstReference(field.Reference.Name),
+				                                              new LiteralStringExpression(field.Reference.Name),
 				                                              new TypeTokenExpression(field.Reference.FieldType));
 				ctor.CodeBuilder.AddStatement(new AssignStatement(
 				                              	field,

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"),
-					new ConstReference(targetField.Reference.FieldType.AssemblyQualifiedName)));
+					new LiteralStringExpression("__targetFieldType"),
+					new LiteralStringExpression(targetField.Reference.FieldType.AssemblyQualifiedName)));
 
 			codebuilder.AddStatement(
 				new MethodInvocationExpression(
 					serializationInfo,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference("__theInterface"),
-					new ConstReference(targetType.AssemblyQualifiedName)));
+					new LiteralStringExpression("__theInterface"),
+					new LiteralStringExpression(targetType.AssemblyQualifiedName)));
 		}
 	}
 }

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

@@ -57,9 +57,9 @@ protected void ImplementGetObjectData(ClassEmitter emitter)
 					new MethodInvocationExpression(
 						null,
 						TypeMethods.StaticGetType,
-						new ConstReference(typeof(ProxyObjectReference).AssemblyQualifiedName),
-						new ConstReference(1),
-						new ConstReference(0))));
+						new LiteralStringExpression(typeof(ProxyObjectReference).AssemblyQualifiedName),
+						new LiteralBoolExpression(true),
+						new LiteralBoolExpression(false))));
 
 			getObjectData.CodeBuilder.AddStatement(
 				new MethodInvocationExpression(
@@ -93,36 +93,36 @@ protected void ImplementGetObjectData(ClassEmitter emitter)
 					new AssignArrayStatement(
 						interfacesLocal,
 						i,
-						new ConstReference(interfaces[i].AssemblyQualifiedName)));
+						new LiteralStringExpression(interfaces[i].AssemblyQualifiedName)));
 			}
 
 			getObjectData.CodeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					info,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference("__interfaces"),
+					new LiteralStringExpression("__interfaces"),
 					interfacesLocal));
 
 			getObjectData.CodeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					info,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference("__baseType"),
-					new ConstReference(emitter.BaseType.AssemblyQualifiedName)));
+					new LiteralStringExpression("__baseType"),
+					new LiteralStringExpression(emitter.BaseType.AssemblyQualifiedName)));
 
 			getObjectData.CodeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					info,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference("__proxyGenerationOptions"),
+					new LiteralStringExpression("__proxyGenerationOptions"),
 					emitter.GetField("proxyGenerationOptions")));
 
 			getObjectData.CodeBuilder.AddStatement(
 				new MethodInvocationExpression(
 					info,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference("__proxyTypeId"),
-					new ConstReference(proxyTypeId)));
+					new LiteralStringExpression("__proxyTypeId"),
+					new LiteralStringExpression(proxyTypeId)));
 
 			CustomizeGetObjectData(getObjectData.CodeBuilder, info, getObjectData.Arguments[1], emitter);
 
@@ -136,7 +136,7 @@ protected virtual void AddAddValueInvocation(ArgumentReference serializationInfo
 				new MethodInvocationExpression(
 					serializationInfo,
 					SerializationInfoMethods.AddValue_Object,
-					new ConstReference(field.Reference.Name),
+					new LiteralStringExpression(field.Reference.Name),
 					field));
 			return;
 		}

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

@@ -62,32 +62,6 @@ public static void EmitLoadIndirectOpCodeForType(ILGenerator gen, Type type)
 			}
 		}
 
-		/// <summary>
-		///   Emits a load opcode of the appropriate kind for a constant string or
-		///   primitive value.
-		/// </summary>
-		public static void EmitLoadOpCodeForConstantValue(ILGenerator gen, object value)
-		{
-			if (value is string)
-			{
-				gen.Emit(OpCodes.Ldstr, value.ToString());
-			}
-			else if (value is Int32)
-			{
-				var code = LdcOpCodesDictionary.Instance[value.GetType()];
-				gen.Emit(code, (int)value);
-			}
-			else if (value is bool)
-			{
-				var code = LdcOpCodesDictionary.Instance[value.GetType()];
-				gen.Emit(code, Convert.ToInt32(value));
-			}
-			else
-			{
-				throw new NotSupportedException();
-			}
-		}
-
 		/// <summary>
 		///   Emits a load opcode of the appropriate kind for the constant default value of a
 		///   type, such as 0 for value types and null for reference types.

src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LiteralBoolExpression.cs

@@ -0,0 +1,33 @@
+// Copyright 2004-2021 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 Castle.DynamicProxy.Generators.Emitters.SimpleAST
+{
+	using System.Reflection.Emit;
+
+	internal class LiteralBoolExpression : IExpression
+	{
+		private readonly bool value;
+
+		public LiteralBoolExpression(bool value)
+		{
+			this.value = value;
+		}
+
+		public void Emit(ILGenerator gen)
+		{
+			gen.Emit(value ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
+		}
+	}
+}

src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LiteralStringExpression.cs

@@ -0,0 +1,33 @@
+// Copyright 2004-2021 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 Castle.DynamicProxy.Generators.Emitters.SimpleAST
+{
+	using System.Reflection.Emit;
+
+	internal class LiteralStringExpression : IExpression
+	{
+		private readonly string value;
+
+		public LiteralStringExpression(string value)
+		{
+			this.value = value;
+		}
+
+		public void Emit(ILGenerator gen)
+		{
+			gen.Emit(OpCodes.Ldstr, value);
+		}
+	}
+}

src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LoadRefArrayElementExpression.cs

@@ -19,23 +19,18 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	internal class LoadRefArrayElementExpression : IExpression
 	{
 		private readonly Reference arrayReference;
-		private readonly ConstReference index;
+		private readonly LiteralIntExpression index;
 
 		public LoadRefArrayElementExpression(int index, Reference arrayReference)
-			: this(new ConstReference(index), arrayReference)
 		{
-		}
-
-		public LoadRefArrayElementExpression(ConstReference index, Reference arrayReference)
-		{
-			this.index = index;
+			this.index = new LiteralIntExpression(index);
 			this.arrayReference = arrayReference;
 		}
 
 		public void Emit(ILGenerator gen)
 		{
 			ArgumentsUtil.EmitLoadOwnerAndReference(arrayReference, gen);
-			ArgumentsUtil.EmitLoadOwnerAndReference(index, gen);
+			index.Emit(gen);
 			gen.Emit(OpCodes.Ldelem_Ref);
 		}
 	}

src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ThrowStatement.cs

@@ -32,9 +32,9 @@ public ThrowStatement(Type exceptionType, string errorMessage)
 		public void Emit(ILGenerator gen)
 		{
 			var ci = exceptionType.GetConstructor(new[] { typeof(string) });
-			var constRef = new ConstReference(errorMessage);
+			var message = new LiteralStringExpression(errorMessage);
 
-			var creationStmt = new NewInstanceExpression(ci, constRef);
+			var creationStmt = new NewInstanceExpression(ci, message);
 
 			creationStmt.Emit(gen);