Move helper methods to processors where they are used

src/DelegateDecompiler/Processor.cs

@@ -225,9 +225,7 @@ static int ProcessInstruction(ProcessorState state, Instruction instruction)
         static LambdaExpression DecompileLambdaExpression(MethodInfo method, Func<Expression> @this)
         {
             if (method.IsStatic)
-            {
                 return AnonymousDelegatesCache.GetOrAdd(method, m => m.Decompile());
-            }
 
             //Should always call.
             var expression = @this();
@@ -284,32 +282,7 @@ internal static BinaryExpression MakeBinaryExpression(Address left, Address righ
             return Expression.MakeBinary(expressionType, left, right);
         }
 
-        internal static UnaryExpression MakeUnaryExpression(Expression operand, ExpressionType expressionType)
-        {
-            operand = ConvertEnumExpressionToUnderlyingType(operand);
-
-            return Expression.MakeUnary(expressionType, operand, operand.Type);
-        }
-
-        internal static Expression Box(Expression expression, Type type)
-        {
-            if (expression.Type == type)
-                return expression;
-
-            var constantExpression = expression as ConstantExpression;
-            if (constantExpression != null)
-            {
-                if (type.IsEnum)
-                    return Expression.Constant(Enum.ToObject(type, constantExpression.Value));
-            }
-
-            if (expression.Type.IsEnum)
-                return Expression.Convert(expression, type);
-
-            return expression;
-        }
-
-        static Expression ConvertEnumExpressionToUnderlyingType(Expression expression)
+        internal static Expression ConvertEnumExpressionToUnderlyingType(Expression expression)
         {
             if (expression.Type.IsEnum)
                 return Expression.Convert(expression, expression.Type.GetEnumUnderlyingType());

src/DelegateDecompiler/Processors/BoxProcessor.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq.Expressions;
 using System.Reflection.Emit;
 using Mono.Reflection;
 
@@ -14,6 +15,23 @@ public static void Register(Dictionary<OpCode, IProcessor> processors)
 
     public void Process(ProcessorState state, Instruction instruction)
     {
-        state.Stack.Push(Processor.Box(state.Stack.Pop(), (Type)instruction.Operand));
+        state.Stack.Push(Box(state.Stack.Pop(), (Type)instruction.Operand));
+    }
+
+    static Expression Box(Expression expression, Type type)
+    {
+        if (expression.Type == type)
+            return expression;
+
+        if (expression is ConstantExpression constantExpression)
+        {
+            if (type.IsEnum)
+                return Expression.Constant(Enum.ToObject(type, constantExpression.Value));
+        }
+
+        if (expression.Type.IsEnum)
+            return Expression.Convert(expression, type);
+
+        return expression;
     }
 }

src/DelegateDecompiler/Processors/LdlocConstantProcessor.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using System.Reflection.Emit;
+using Mono.Reflection;
+
+namespace DelegateDecompiler.Processors
+{
+    internal class LdlocConstantProcessor(int index) : IProcessor
+    {
+        public static void Register(Dictionary<OpCode, IProcessor> processors)
+        {
+            processors.Register(new LdlocConstantProcessor(0), OpCodes.Ldloc_0);
+            processors.Register(new LdlocConstantProcessor(1), OpCodes.Ldloc_1);
+            processors.Register(new LdlocConstantProcessor(2), OpCodes.Ldloc_2);
+            processors.Register(new LdlocConstantProcessor(3), OpCodes.Ldloc_3);
+        }
+
+        public void Process(ProcessorState state, Instruction instruction)
+        {
+            var local = state.Locals[index];
+            state.Stack.Push(local.Address);
+        }
+    }
+}

src/DelegateDecompiler/Processors/LdlocProcessor.cs → src/DelegateDecompiler/Processors/LdlocVariableProcessor.cs

@@ -1,30 +1,10 @@
-using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Reflection.Emit;
 using Mono.Reflection;
 
 namespace DelegateDecompiler.Processors;
 
-// Processor for constant local variable indices (ldloc.0, ldloc.1, etc.)
-internal class LdlocConstantProcessor(int index) : IProcessor
-{
-    public static void Register(Dictionary<OpCode, IProcessor> processors)
-    {
-        processors.Register(new LdlocConstantProcessor(0), OpCodes.Ldloc_0);
-        processors.Register(new LdlocConstantProcessor(1), OpCodes.Ldloc_1);
-        processors.Register(new LdlocConstantProcessor(2), OpCodes.Ldloc_2);
-        processors.Register(new LdlocConstantProcessor(3), OpCodes.Ldloc_3);
-    }
-
-    public void Process(ProcessorState state, Instruction instruction)
-    {
-        var local = state.Locals[index];
-        state.Stack.Push(local.Address);
-    }
-}
-
-// Processor for dynamic local variable index resolution (ldloc, ldloc.s, ldloca, ldloca.s)
 internal class LdlocVariableProcessor : IProcessor
 {
     public static void Register(Dictionary<OpCode, IProcessor> processors)

src/DelegateDecompiler/Processors/UnaryExpressionProcessor.cs

@@ -16,6 +16,13 @@ public static void Register(Dictionary<OpCode, IProcessor> processors)
     public void Process(ProcessorState state, Instruction instruction)
     {
         var val = state.Stack.Pop();
-        state.Stack.Push(Processor.MakeUnaryExpression(val, expressionType));
+        state.Stack.Push(MakeUnaryExpression(val, expressionType));
+    }
+
+    static UnaryExpression MakeUnaryExpression(Expression operand, ExpressionType expressionType)
+    {
+        operand = Processor.ConvertEnumExpressionToUnderlyingType(operand);
+
+        return Expression.MakeUnary(expressionType, operand, operand.Type);
     }
 }