Add support for starg opcode (#268)

+semver:feature

---------

Co-authored-by: Alex Zaytsev <hazzik@gmail.com>

Author: Copilot

src/DelegateDecompiler.Tests/StargTests.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Linq.Expressions;
+using NUnit.Framework;
+
+namespace DelegateDecompiler.Tests
+{
+    [TestFixture]
+    public class StargTests : DecompilerTestsBase
+    {
+        public class TestClass
+        {
+            public static int ModifyParameter(int value)
+            {
+                value = value + 1;
+                return value;
+            }
+
+            public static int ModifyParameterWithCondition(int value)
+            {
+                if (value > 0)
+                    value = value * 2;
+                else
+                    value = -value;
+                return value;
+            }
+
+            public static string ModifyStringParameter(string text)
+            {
+                if (text != null)
+                    text = text + " modified";
+                return text;
+            }
+
+            // Non-static method for testing instance method parameter modification
+            public int ModifyInstanceParameter(int value)
+            {
+                value = value + 1;
+                return value;
+            }
+        }
+
+        [Test]
+        public void StargProcessor_ShouldHandleSimpleParameterModification()
+        {
+            Expression<Func<int, int>> expected = value => value + 1;
+            Func<int, int> compiled = TestClass.ModifyParameter;
+            Test(expected, compiled);
+        }
+
+        [Test]
+        public void StargProcessor_ShouldHandleConditionalParameterModification()
+        {
+            Expression<Func<int, int>> expected = value => value <= 0 ? -value : value * 2;
+            Func<int, int> compiled = TestClass.ModifyParameterWithCondition;
+            Test(expected, compiled);
+        }
+
+        [Test]
+        public void StargProcessor_ShouldHandleStringParameterModification()
+        {
+            Expression<Func<string, string>> expected = text => text == null ? text : text + " modified";
+            Func<string, string> compiled = TestClass.ModifyStringParameter;
+            Test(expected, compiled);
+        }
+
+        [Test]
+        public void StargProcessor_ShouldHandleInstanceMethodParameterModification()
+        {
+            var method = typeof(TestClass).GetMethod(nameof(TestClass.ModifyInstanceParameter));
+            var expression = method.Decompile();
+
+            Assert.That(expression.ToString(), Is.EqualTo("(this, value) => (value + 1)"));
+        }
+    }
+}

src/DelegateDecompiler/MethodBodyDecompiler.cs

@@ -16,21 +16,23 @@ public static LambdaExpression Decompile(MethodInfo method)
 
         public static LambdaExpression Decompile(MethodInfo method, Type declaringType)
         {
-            var args = method.GetParameters()
-                .Select(p => (Address)Expression.Parameter(p.ParameterType, p.Name))
+            var parameters = method.GetParameters()
+                .Select(p => Expression.Parameter(p.ParameterType, p.Name))
                 .ToList();
 
             var methodType = declaringType ?? method.DeclaringType;
-            if (!method.IsStatic)
-                args.Insert(0, Expression.Parameter(methodType, "this"));
+            if (!method.IsStatic) 
+                parameters.Insert(0, Expression.Parameter(methodType, "this"));
+
+            var args = parameters.ConvertAll(x => (Address)x);
 
             var expression = method.IsVirtual && !method.IsFinal
                 ? DecompileOverridable(methodType, method, args)
                 : DecompileConcrete(method, args);
 
             var optimizedExpression = expression.Optimize();
 
-            return Expression.Lambda(optimizedExpression, args.Select(x => (ParameterExpression)x.Expression));
+            return Expression.Lambda(optimizedExpression, parameters);
         }
 
         static Expression DecompileConcrete(MethodInfo method, IList<Address> args)
@@ -42,7 +44,7 @@ static Expression DecompileConcrete(MethodInfo method, IList<Address> args)
             var locals = addresses.ToArray();
 
             var instructions = method.GetInstructions();
-            var expression = Processor.Process(locals, args, instructions.First(), method.ReturnType);
+            var expression = Processor.Process(method.IsStatic, locals, args, instructions.First(), method.ReturnType);
             var localParameters = locals
                 .Select(l => l.Address.Expression)
                 .OfType<ParameterExpression>()

src/DelegateDecompiler/Processor.cs

@@ -24,10 +24,10 @@ internal class Processor
         static readonly ConcurrentDictionary<MethodInfo, LambdaExpression> AnonymousDelegatesCache =
             new ConcurrentDictionary<MethodInfo, LambdaExpression>();
 
-        public static Expression Process(VariableInfo[] locals, IList<Address> args, Instruction instruction, Type returnType)
+        public static Expression Process(bool isStatic, VariableInfo[] locals, IList<Address> args, Instruction instruction, Type returnType)
         {
             Processor processor = new Processor();
-            processor.states.Push(new ProcessorState(new Stack<Address>(), locals, args, instruction));
+            processor.states.Push(new ProcessorState(isStatic, new Stack<Address>(), locals, args, instruction));
 
             var ex = AdjustType(processor.Process(), returnType);
 
@@ -47,6 +47,7 @@ public static Expression Process(VariableInfo[] locals, IList<Address> args, Ins
             new UnaryExpressionProcessor(),
             new CgtUnProcessor(),
             new LdargProcessor(),
+            new StargProcessor(),
             new LdelemProcessor(),
             new LdlenProcessor(),
             new LdlocProcessor(),

src/DelegateDecompiler/ProcessorState.cs

@@ -8,6 +8,7 @@
 namespace DelegateDecompiler
 {
     class ProcessorState(
+        bool isStatic,
         Stack<Address> stack,
         VariableInfo[] locals,
         IList<Address> args,
@@ -21,14 +22,22 @@ class ProcessorState(
         public IList<Address> Args { get; } = args;
         public Instruction Last { get; } = last;
         public Action RunNext { get; set; }
+        public bool IsStatic { get; } = isStatic;
 
         public Instruction Instruction { get; set; } = instruction;
 
         public ProcessorState Clone(Instruction instruction, Instruction last = null)
         {
             var addressMap = new Dictionary<Address, Address>();
             var buffer = Stack.Select(address => address.Clone(addressMap)).Reverse();
-            var state = new ProcessorState(new Stack<Address>(buffer), new VariableInfo[Locals.Length], Args.ToArray(), instruction, last, Delegates);
+            
+            var clonedArgs = new Address[Args.Count];
+            for (var i = 0; i < Args.Count; i++)
+            {
+                clonedArgs[i] = Args[i].Clone(addressMap);
+            }
+            
+            var state = new ProcessorState(IsStatic, new Stack<Address>(buffer), new VariableInfo[Locals.Length], clonedArgs, instruction, last, Delegates);
             for (var i = 0; i < Locals.Length; i++)
             {
                 state.Locals[i] = new VariableInfo(Locals[i].Type)
@@ -48,6 +57,14 @@ public void Merge(Expression test, ProcessorState leftState, ProcessorState righ
                 var rightLocal = rightState.Locals[i];
                 Locals[i].Address = Address.Merge(test, leftLocal.Address, rightLocal.Address, addressMap);
             }
+            
+            for (var i = 0; i < leftState.Args.Count; i++)
+            {
+                var leftArg = leftState.Args[i];
+                var rightArg = rightState.Args[i];
+                Args[i] = Address.Merge(test, leftArg, rightArg, addressMap);
+            }
+            
             var buffer = new List<Address>();
             while (leftState.Stack.Count > 0 || rightState.Stack.Count > 0)
             {

src/DelegateDecompiler/Processors/LdargProcessor.cs

@@ -34,7 +34,6 @@ public bool Process(ProcessorState state)
     static int GetParameterIndex(ProcessorState state)
     {
         var operand = (ParameterInfo)state.Instruction.Operand;
-        var arg = state.Args.Single(x => ((ParameterExpression)x.Expression).Name == operand.Name);
-        return state.Args.IndexOf(arg);
+        return state.IsStatic ? operand.Position : operand.Position + 1;
     }
 }

src/DelegateDecompiler/Processors/StargProcessor.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Reflection.Emit;
+using Mono.Reflection;
+
+namespace DelegateDecompiler.Processors;
+
+internal class StargProcessor : IProcessor
+{
+    static readonly Dictionary<OpCode, Func<ProcessorState, int>> Operations = new()
+    {
+        { OpCodes.Starg_S, GetParameterIndex },
+        { OpCodes.Starg, GetParameterIndex },
+    };
+
+    public bool Process(ProcessorState state)
+    {
+        if (!Operations.TryGetValue(state.Instruction.OpCode, out var value))
+            return false;
+
+        StArg(state, value(state));
+        return true;
+    }
+
+    static void StArg(ProcessorState state, int index)
+    {
+        var arg = state.Args[index];
+        var expression = Processor.AdjustType(state.Stack.Pop(), arg.Type);
+        arg.Expression = expression.Type == arg.Type ? expression : Expression.Convert(expression, arg.Type);
+    }
+
+    static int GetParameterIndex(ProcessorState state)
+    {
+        var operand = (ParameterInfo)state.Instruction.Operand;
+        return state.IsStatic ? operand.Position : operand.Position + 1;
+    }
+}