ConstReference is not a reference at all

This type gets used to emit constant values, so it obviously should not
be a `Reference` because one can't load the address of a constant value
nor store anything in it.

`ConstReference` gets replaced with the existing `LiteralIntExpression`
plus new sibling types `Literal{Bool,String}Expression`. This in turn
makes a method inside `OpCodeUtil` obsolete.

Author: stakx

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(IMemberEmitter member, ILGenerator gen)
+		{
+			gen.Emit(value ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
+		}
+	}
+}

src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/ConstReference.cs renamed to src/Castle.Core/DynamicProxy/Generators/Emitters/SimpleAST/LiteralStringExpression.cs

@@ -14,41 +14,22 @@
 
 namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 {
-	using System;
 	using System.Diagnostics;
-	using System.Reflection;
 	using System.Reflection.Emit;
 
 	[DebuggerDisplay("{value}")]
-	internal class ConstReference : TypeReference
+	internal class LiteralStringExpression : IExpression
 	{
-		private readonly object value;
+		private readonly string value;
 
-		public ConstReference(object value)
-			: base(value.GetType())
+		public LiteralStringExpression(string value)
 		{
-			Debug.Assert(value.GetType().IsPrimitive || value is string, "Invalid type to ConstReference");
-
 			this.value = value;
 		}
 
-		public override void Generate(ILGenerator gen)
-		{
-		}
-
-		public override void LoadAddressOfReference(ILGenerator gen)
-		{
-			throw new NotSupportedException();
-		}
-
-		public override void LoadReference(ILGenerator gen)
-		{
-			OpCodeUtil.EmitLoadOpCodeForConstantValue(gen, value);
-		}
-
-		public override void StoreReference(ILGenerator gen)
+		public void Emit(IMemberEmitter member, ILGenerator gen)
 		{
-			throw new NotImplementedException("ConstReference.StoreReference");
+			gen.Emit(OpCodes.Ldstr, value);
 		}
 	}
 }

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

@@ -20,25 +20,20 @@ namespace Castle.DynamicProxy.Generators.Emitters.SimpleAST
 	internal class LoadArrayElementExpression : IExpression
 	{
 		private readonly Reference arrayReference;
-		private readonly ConstReference index;
+		private readonly LiteralIntExpression index;
 		private readonly Type returnType;
 
 		public LoadArrayElementExpression(int index, Reference arrayReference, Type returnType)
-			: this(new ConstReference(index), arrayReference, returnType)
 		{
-		}
-
-		public LoadArrayElementExpression(ConstReference index, Reference arrayReference, Type returnType)
-		{
-			this.index = index;
+			this.index = new LiteralIntExpression(index);
 			this.arrayReference = arrayReference;
 			this.returnType = returnType;
 		}
 
 		public void Emit(IMemberEmitter member, ILGenerator gen)
 		{
 			ArgumentsUtil.EmitLoadOwnerAndReference(arrayReference, gen);
-			ArgumentsUtil.EmitLoadOwnerAndReference(index, gen);
+			index.Emit(member, gen);
 			gen.Emit(OpCodes.Ldelem, returnType);
 		}
 	}

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(IMemberEmitter member, ILGenerator gen)
 		{
 			ArgumentsUtil.EmitLoadOwnerAndReference(arrayReference, gen);
-			ArgumentsUtil.EmitLoadOwnerAndReference(index, gen);
+			index.Emit(member, gen);
 			gen.Emit(OpCodes.Ldelem_Ref);
 		}
 	}

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

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