Merge branch 'main' into gh-actions

Author: hazzik

.github/copilot-instructions.md

@@ -0,0 +1,72 @@
+# DelegateDecompiler - GitHub Copilot Instructions
+
+## Project Overview
+
+DelegateDecompiler is a .NET library that decompiles delegates and method bodies to their lambda representation. It enables computed properties in LINQ queries by translating `[Computed]` attributes into executable expressions that can be processed by Entity Framework and other ORMs.
+
+## Core Components
+
+- **`ComputedAttribute`**: Marks properties/methods for decompilation
+- **`MethodBodyDecompiler`**: Core IL decompilation engine  
+- **`DecompileExtensions`**: Public API for decompiling delegates/queries
+- **`Processors/`**: Pluggable processors for different IL opcodes
+
+## Build & Test
+
+```bash
+# Restore packages
+dotnet restore
+
+# Build the solution
+dotnet build --no-restore -c Release -p:DisableGitVersionTask=true
+
+# Run tests
+dotnet test --no-build -c Release -f net8.0 src/DelegateDecompiler.Tests
+dotnet test --no-build -c Release -f net8.0 src/DelegateDecompiler.Tests.VB
+dotnet test --no-build -c Release -f net8.0 src/DelegateDecompiler.EntityFramework.Tests
+dotnet test --no-build -c Release -f net8.0 src/DelegateDecompiler.EntityFrameworkCore6.Tests
+dotnet test --no-build -c Release -f net8.0 src/DelegateDecompiler.EntityFrameworkCore8.Tests
+dotnet test --no-build -c Release -f net9.0 src/DelegateDecompiler.EntityFrameworkCore9.Tests
+```
+
+**Development Guidelines:**
+- Use test-first approach when adding new features or fixing bugs
+- Ensure core unit tests pass: `src/DelegateDecompiler.Tests` and `src/DelegateDecompiler.Tests.VB` should have no failures
+- Run unit tests frequently during development to catch regressions early
+
+## Project Structure
+
+```
+src/
+├── DelegateDecompiler/                          # Core library
+├── DelegateDecompiler.EntityFramework/          # EF 6.x support
+├── DelegateDecompiler.EntityFrameworkCore5/     # EF Core 5+ support 
+├── DelegateDecompiler.Tests/                    # Core library tests
+└── DelegateDecompiler.EntityFramework*.Tests/   # EF integration tests
+```
+
+## Usage Example
+
+```csharp
+class Employee
+{
+    [Computed]
+    public string FullName => FirstName + " " + LastName;
+    public string FirstName { get; set; }
+    public string LastName { get; set; }
+}
+
+// Usage in LINQ - decompiles FullName to FirstName + " " + LastName
+var results = employees
+    .Where(e => e.FullName == "John Doe")
+    .Decompile()
+    .ToList();
+```
+
+## Development Notes
+
+- **Target Frameworks**: .NET Framework 4.0/4.5, .NET Standard 2.0/2.1, .NET 8.0/9.0
+- **Key Dependency**: Mono.Reflection for IL reading
+- **Testing**: NUnit with automatic documentation generation for EF tests
+- **Architecture**: Pluggable processor pattern for handling IL opcodes
+- **Performance**: Decompilation results are cached using `ConcurrentDictionary`

src/DelegateDecompiler.Tests/OutParametersTest.cs

@@ -15,7 +15,7 @@ public void TestOutParameter()
             var expression = (Expression<Func<string, int>>)MethodBodyDecompiler.Decompile(mi);
 
             Assert.That(expression.ToString(), Is.EqualTo("s => {var Param_0; ... }"));
-            Assert.That(DebugView(expression), Is.EqualTo(@".Lambda #Lambda1<System.Func`2[System.String,System.Int32]>(System.String $s) {
+            Assert.That(DebugView(expression).NormalizeLineEndings(), Is.EqualTo(@".Lambda #Lambda1<System.Func`2[System.String,System.Int32]>(System.String $s) {
     .Block(System.Int32 $var1) {
         .If (
             .Call System.Int32.TryParse(
@@ -27,7 +27,7 @@ .Call System.Int32.TryParse(
             -1
         }
     }
-}"));
+}".NormalizeLineEndings()));
 
             var compiledMethod = expression.Compile();
 

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.Tests/StringExtensions.cs

@@ -0,0 +1,6 @@
+namespace DelegateDecompiler.Tests;
+
+internal static class StringExtensions
+{
+    public static string NormalizeLineEndings(this string s) => s.Replace("\r\n", "\n");
+}

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;
+    }
+}