Merge pull request #60 from messerli-informatik-ag/result-stack-trace

Added a valid stack trace to the exception in the Result monad

Author: FreeApophis

Funcky.Test/FunctionalAssert.cs

@@ -0,0 +1,11 @@
+namespace Funcky.Test
+{
+    internal class FunctionalAssert
+    {
+        public static void Unmatched()
+            => throw new UnmatchedException();
+
+        public static void Unmatched(string unmatchedCase)
+            => throw new UnmatchedException(unmatchedCase);
+    }
+}

Funcky.Test/ResultTest.cs

@@ -1,5 +1,6 @@
-using System;
+using System;
 using System.IO;
+using System.Linq;
 using Funcky.Monads;
 using Xunit;
 using static Funcky.Functional;
@@ -99,5 +100,49 @@ public static TheoryData<Result<int>, bool> GetResults()
                 { Result<int>.Ok(42), true },
                 { Result<int>.Error(new InvalidCastException()), false },
             };
+
+        [Fact]
+        public void GivenAResultWithAnExceptionWeGetAStackTrace()
+        {
+            var arbitrayNumberOfStackFrames = 3;
+
+            InterestingStackTrace(arbitrayNumberOfStackFrames)
+              .Match(
+                ok: v => FunctionalAssert.Unmatched("ok"),
+                error: e => Assert.NotNull(e.StackTrace));
+        }
+
+        [Fact]
+        public void GivenAResultWithAnExceptionTheStackTraceStartsInCreationMethod()
+        {
+            var arbitrayNumberOfStackFrames = 0;
+
+            InterestingStackTrace(arbitrayNumberOfStackFrames)
+              .Match(
+                ok: v => FunctionalAssert.Unmatched("ok"),
+                error: IsInterestingStackTraceFirst);
+        }
+
+        private void IsInterestingStackTraceFirst(Exception exception)
+        {
+            if (exception.StackTrace is { })
+            {
+                var lines = exception.StackTrace.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
+
+                Assert.StartsWith("   at Funcky.Test.ResultTest.InterestingStackTrace(Int32 n)", lines.First());
+            }
+            else
+            {
+                FunctionalAssert.Unmatched("else");
+            }
+        }
+
+        private Result<int> InterestingStackTrace(int n)
+            => n == 0
+                ? Result<int>.Error(new InvalidCastException())
+                : Indirection(n - 1);
+
+        private Result<int> Indirection(int n)
+            => InterestingStackTrace(n);
     }
 }

Funcky.Test/UnmatchedException.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace Funcky.Test
+{
+    internal class UnmatchedException : Exception
+    {
+        public UnmatchedException()
+            : base("Wrong pattern matched.")
+        {
+        }
+
+        public UnmatchedException(string? unmatchedCase)
+            : base($"Wrong pattern matched: the case '{unmatchedCase}' has been matched accidentally.")
+        {
+        }
+    }
+}

Funcky/Monads/ExceptionUtilities.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Diagnostics;
+using System.Reflection;
+
+namespace Funcky.Monads
+{
+    internal static class ExceptionUtilities
+    {
+        private static readonly FieldInfo STACK_TRACE_STRING_FI = typeof(Exception).GetField("_stackTraceString", BindingFlags.NonPublic | BindingFlags.Instance);
+        private static readonly Type TRACE_FORMAT_TI = Type.GetType("System.Diagnostics.StackTrace").GetNestedType("TraceFormat", BindingFlags.NonPublic);
+        private static readonly MethodInfo TRACE_TO_STRING_MI = typeof(StackTrace).GetMethod("ToString", BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { TRACE_FORMAT_TI }, null);
+
+        public static Exception SetStackTrace(this Exception target, StackTrace stack)
+        {
+            var getStackTraceString = TRACE_TO_STRING_MI.Invoke(stack, new object[] { Enum.GetValues(TRACE_FORMAT_TI).GetValue(0) });
+            STACK_TRACE_STRING_FI.SetValue(target, getStackTraceString);
+            return target;
+        }
+    }
+}

Funcky/Monads/Result.cs

@@ -1,9 +1,12 @@
 using System;
+using System.Diagnostics;
 
 namespace Funcky.Monads
 {
     public readonly struct Result<TValidResult>
     {
+        private const int SkipLowestStackFrame = 1;
+
         private readonly TValidResult _result;
         private readonly Exception _error;
 
@@ -32,6 +35,8 @@ public static Result<TValidResult> Ok(TValidResult item)
 
         public static Result<TValidResult> Error(Exception item)
         {
+            ExceptionUtilities.SetStackTrace(item, new StackTrace(SkipLowestStackFrame, true));
+
             return new Result<TValidResult>(item);
         }
 

changelog.md

@@ -17,4 +17,6 @@
 * Added overload for AndThen which flattens the Option
 * Add `Where` method to `Option<T>`, which allows filtering the `Option` by a predicate.
 * Add overload for `Option<T>.SelectMany` that takes only a selector.
- 
+
+## Unpublished
+* `Exception` created by `Result` monad contains valid stack trace