Add basic support for Throw opcode

src/DelegateDecompiler.Tests/ThrowIntegrationTests.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Linq.Expressions;
+using NUnit.Framework;
+
+namespace DelegateDecompiler.Tests
+{
+    [TestFixture]
+    public class ThrowTests : DecompilerTestsBase
+    {
+        [Test]
+        public void SimpleThrow()
+        {
+            Action compiled = () => throw new ArgumentException("test");
+
+            // Should decompile without throwing NotSupportedException
+            Assert.DoesNotThrow(() => {
+                var decompiled = compiled.Decompile();
+                Assert.That(decompiled, Is.Not.Null);
+                Assert.That(decompiled.Body, Is.Not.Null);
+                Assert.That(decompiled.Body.NodeType, Is.EqualTo(ExpressionType.Throw));
+            });
+        }
+
+        [Test]
+        public void ConditionalThrowInTernaryOperator()
+        {
+            Func<int, string> compiled = x => x > 0 ? "positive" : throw new ArgumentException("negative");
+
+            // Should decompile without throwing NotSupportedException
+            Assert.DoesNotThrow(() => {
+                var decompiled = compiled.Decompile();
+                Assert.That(decompiled, Is.Not.Null);
+                Assert.That(decompiled.Body, Is.Not.Null);
+            });
+        }
+
+        [Test]
+        public void IfStatementWithThrow()
+        {
+            Action<int> compiled = x => { if (x < 0) throw new ArgumentException("negative"); };
+
+            // Should decompile without throwing NotSupportedException
+            Assert.DoesNotThrow(() => {
+                var decompiled = compiled.Decompile();
+                Assert.That(decompiled, Is.Not.Null);
+                Assert.That(decompiled.Body, Is.Not.Null);
+            });
+        }
+
+        public class TestClass
+        {
+            public int Value { get; set; }
+
+            [Computed]
+            public int PositiveValue => Value > 0 ? Value : throw new ArgumentException("Value must be positive");
+        }
+
+        [Test]
+        public void ComputedPropertyWithThrow()
+        {
+            var propertyInfo = typeof(TestClass).GetProperty(nameof(TestClass.PositiveValue));
+            var getterMethod = propertyInfo.GetGetMethod();
+
+            // Should decompile without throwing NotSupportedException
+            Assert.DoesNotThrow(() => {
+                var decompiled = getterMethod.Decompile();
+                Assert.That(decompiled, Is.Not.Null);
+                Assert.That(decompiled.Body, Is.Not.Null);
+            });
+        }
+    }
+}

src/DelegateDecompiler/Processor.cs

@@ -59,6 +59,7 @@ public static Expression Process(bool isStatic, VariableInfo[] locals, IList<Add
             new StfldProcessor(),
             new StsfldProcessor(),
             new StelemProcessor(),
+            new ThrowProcessor(),
             // This should be last one
             new UnsupportedOpcodeProcessor()
         };

src/DelegateDecompiler/ProcessorState.cs

@@ -68,9 +68,23 @@ public void Merge(Expression test, ProcessorState leftState, ProcessorState righ
             var buffer = new List<Address>();
             while (leftState.Stack.Count > 0 || rightState.Stack.Count > 0)
             {
-                var rightExpression = rightState.Stack.Pop();
-                var leftExpression = leftState.Stack.Pop();
-                buffer.Add(Address.Merge(test, leftExpression, rightExpression, addressMap));
+                Address rightExpression = rightState.Stack.Count > 0 ? rightState.Stack.Pop() : null;
+                Address leftExpression = leftState.Stack.Count > 0 ? leftState.Stack.Pop() : null;
+
+                if (leftExpression != null && rightExpression != null)
+                {
+                    buffer.Add(Address.Merge(test, leftExpression, rightExpression, addressMap));
+                }
+                else if (leftExpression != null)
+                {
+                    // Right side threw, use left side with conditional
+                    buffer.Add(leftExpression);
+                }
+                else if (rightExpression != null)
+                {
+                    // Left side threw, use right side with conditional
+                    buffer.Add(rightExpression);
+                }
             }
             Stack.Clear();
             foreach (var address in Enumerable.Reverse(buffer))

src/DelegateDecompiler/Processors/ThrowProcessor.cs

@@ -0,0 +1,19 @@
+using System.Linq.Expressions;
+using System.Reflection.Emit;
+
+namespace DelegateDecompiler.Processors;
+
+internal class ThrowProcessor : IProcessor
+{
+    public bool Process(ProcessorState state)
+    {
+        if (state.Instruction.OpCode == OpCodes.Throw)
+        {
+            var exception = state.Stack.Pop();
+            state.Stack.Push(Expression.Throw(exception));
+            return true;
+        }
+
+        return false;
+    }
+}