Harden expression evaluation with fallbacks and sentinels

Author: yevhen

CLAUDE.md

@@ -421,4 +421,5 @@ async\method: Suffix with `Async` =\> `GetDataAsync()`
 - Reflection helpers should tolerate missing overloads (e.g., `MemoryExtensions.ToArray`) to prevent type initializer failures on runtimes where a method shape differs.
 - Compilation can fail with `TypeLoadException`/`ArgumentException` in addition to `InvalidProgramException`; catch broadly and fall back to interpreted compilation or a safe null-returning delegate.
 - Prefer `Compile(preferInterpretation: true)` for expression value extraction to avoid invalid IL, and only drop to null when both interpreted compilation and span normalization fail.
+- If evaluation still fails, return a sentinel (e.g., `EvaluationUnavailable`) and render `<unavailable: reason>` so diagnostics stay honest instead of showing nulls or bogus counts.
 - `NUnit.Assert.ThrowsAsync<T>()` returns the exception instance (not a `Task`), so async tests should await a real async assertion (e.g., `action.Should().ThrowAsync<T>()`) to avoid CS1998 warnings.

learnings.md

@@ -132,6 +132,7 @@ This document is organized by topic to consolidate key learnings about the proje
 - **Reflection resilience:** Do not assume specific overloads exist across runtimes; when reflecting for helpers like `MemoryExtensions.ToArray`, select via tolerant predicate and allow null fallback to avoid type initializer failures.
 - **Compilation fallback breadth:** Expression compilation can also fail with `TypeLoadException`/`ArgumentException` on byref-like conversions; wrap compilation and fall back to interpreted mode or a null-returning delegate when both paths fail.
 - **Interpretation-first evaluation:** Prefer `Lambda.Compile(preferInterpretation: true)` for expression value extraction to avoid invalid IL generation issues; only return null when both interpreted compilation and span-to-array normalization fail.
+- **Evaluation sentinels:** When evaluation fails, return a recognizable sentinel (e.g., `EvaluationUnavailable`) and have formatters render `<unavailable: reason>` instead of null/incorrect data to keep diagnostics honest.
 - **NUnit Assert.ThrowsAsync return type:** `Assert.ThrowsAsync<T>()` returns the exception instance, not a `Task`, so async test methods need an explicit awaitable (e.g., `action.Should().ThrowAsync<T>()`) to avoid CS1998 warnings.
 
 ## String Diffing Implementation (Increment 5)

src/SharpAssert.Runtime/Features/LinqOperations/LinqOperationFormatter.cs

@@ -3,6 +3,7 @@
 using SharpAssert.Core;
 using SharpAssert.Features.Shared;
 using static SharpAssert.Features.Shared.ExpressionValueEvaluator;
+using static SharpAssert.Features.Shared.EvaluationUnavailableHelpers;
 
 namespace SharpAssert.Features.LinqOperations;
 
@@ -14,6 +15,9 @@ public static FormattedEvaluationResult BuildResult(MethodCallExpression methodC
     {
         var methodName = methodCall.Method.Name;
         var collection = GetValue(methodCall.Object ?? methodCall.Arguments[0]);
+
+        if (IsUnavailable(collection))
+            return new FormattedEvaluationResult(expressionText, value, new[] { DescribeUnavailable(collection) });
 
         var lines = methodName switch
         {
@@ -29,6 +33,9 @@ public static FormattedEvaluationResult BuildResult(MethodCallExpression methodC
     static IReadOnlyList<string> FormatContainsFailure(MethodCallExpression methodCall, object? collection)
     {
         var item = GetValue(methodCall.Arguments.Last()); // Contains item
+        if (IsUnavailable(item))
+            return new[] { DescribeUnavailable(item) };
+
         var collectionStr = FormatCollection(collection);
         var count = GetCount(collection);
 
@@ -41,6 +48,9 @@ static IReadOnlyList<string> FormatContainsFailure(MethodCallExpression methodCa
 
     static IReadOnlyList<string> FormatAnyFailure(MethodCallExpression methodCall, object? collection)
     {
+        if (IsUnavailable(collection))
+            return new[] { DescribeUnavailable(collection) };
+
         var count = GetCount(collection);
 
         if (count == 0)
@@ -57,6 +67,9 @@ static IReadOnlyList<string> FormatAnyFailure(MethodCallExpression methodCall, o
 
     static IReadOnlyList<string> FormatAllFailure(MethodCallExpression methodCall, object? collection)
     {
+        if (IsUnavailable(collection))
+            return new[] { DescribeUnavailable(collection) };
+
         var predicateStr = GetPredicateString(methodCall);
         var predicateArg = GetPredicateArgument(methodCall);
 
@@ -102,6 +115,9 @@ static bool IsMatching(object? item, Delegate predicate)
 
     static string FormatCollection(object? collection)
     {
+        if (IsUnavailable(collection))
+            return DescribeUnavailable(collection);
+
         if (collection is not IEnumerable enumerable) 
             return FormatValue(collection);
 

src/SharpAssert.Runtime/Features/SequenceEqual/SequenceEqualComparer.cs

@@ -4,6 +4,7 @@
 using DiffPlex.Model;
 using SharpAssert.Features.Shared;
 using static SharpAssert.Features.Shared.ExpressionValueEvaluator;
+using static SharpAssert.Features.Shared.EvaluationUnavailableHelpers;
 
 namespace SharpAssert.Features.SequenceEqual;
 
@@ -17,6 +18,19 @@ public static SequenceEqualComparisonResult BuildResult(MethodCallExpression met
     {
         var firstSequence = GetValue(methodCall.Object ?? methodCall.Arguments[0]);
         var secondSequence = GetValue(methodCall.Arguments.Count > 1 ? methodCall.Arguments[1] : methodCall.Arguments[0]);
+
+        if (IsUnavailable(firstSequence) || IsUnavailable(secondSequence))
+        {
+            var error = $"{DescribeUnavailable(firstSequence)}/{DescribeUnavailable(secondSequence)}";
+            return new SequenceEqualComparisonResult(
+                new AssertionOperand(firstSequence, typeof(object)),
+                new AssertionOperand(secondSequence, typeof(object)),
+                methodCall.Arguments.Count > 2,
+                null,
+                null,
+                false,
+                $"SequenceEqual failed: value unavailable ({error})");
+        }
 
         var hasComparer = methodCall.Arguments.Count > 2 ||
                          (methodCall.Object == null && methodCall.Arguments.Count > 2);

src/SharpAssert.Runtime/Features/Shared/EvaluationUnavailable.cs

@@ -0,0 +1,6 @@
+namespace SharpAssert.Features.Shared;
+
+public sealed record EvaluationUnavailable(string Reason)
+{
+    public override string ToString() => $"<unavailable: {Reason}>";
+}

src/SharpAssert.Runtime/Features/Shared/EvaluationUnavailableHelpers.cs

@@ -0,0 +1,10 @@
+namespace SharpAssert.Features.Shared;
+
+static class EvaluationUnavailableHelpers
+{
+    public static bool IsUnavailable(object? value) => value is EvaluationUnavailable;
+
+    public static string DescribeUnavailable(object? value) => value is EvaluationUnavailable unavailable
+        ? unavailable.ToString()
+        : "<unavailable>";
+}

src/SharpAssert.Runtime/Features/Shared/ExpressionValueEvaluator.cs

@@ -17,16 +17,17 @@ static class ExpressionValueEvaluator
     public static Func<object> Compile(Expression expression)
     {
         var normalized = Normalize(expression);
-        var lambda = Expression.Lambda<Func<object>>(normalized);
 
-        try
-        {
-            return lambda.Compile(preferInterpretation: true);
-        }
-        catch
-        {
-            return NullEvaluator;
-        }
+        if (TryInterpret(normalized, out var interpreted))
+            return interpreted;
+
+        if (TryJit(normalized, out var jit))
+            return jit;
+
+        if (TryManualEvaluate(normalized, out var manual))
+            return manual;
+
+        return () => new EvaluationUnavailable("Evaluation failed");
     }
 
     static MethodInfo? ResolveToArrayMethod()
@@ -76,6 +77,128 @@ static Expression Normalize(Expression expression)
             return Expression.Convert(call, typeof(object));
         }
 
-        return Expression.Constant(null, typeof(object));
+        return Expression.Constant(new EvaluationUnavailable("Span conversion unavailable"), typeof(object));
+    }
+
+    static bool TryInterpret(Expression expression, out Func<object> result)
+    {
+        try
+        {
+            result = Expression.Lambda<Func<object>>(expression).Compile(preferInterpretation: true);
+            return true;
+        }
+        catch
+        {
+            result = NullEvaluator;
+            return false;
+        }
+    }
+
+    static bool TryJit(Expression expression, out Func<object> result)
+    {
+        try
+        {
+            result = Expression.Lambda<Func<object>>(expression).Compile();
+            return true;
+        }
+        catch
+        {
+            result = NullEvaluator;
+            return false;
+        }
+    }
+
+    static bool TryManualEvaluate(Expression expression, out Func<object> result)
+    {
+        if (TryEvaluateExpression(expression, out var value))
+        {
+            result = () => value;
+            return true;
+        }
+
+        result = NullEvaluator;
+        return false;
+    }
+
+    static bool TryEvaluateExpression(Expression expression, out object value)
+    {
+        switch (expression)
+        {
+            case ConstantExpression constant:
+                value = constant.Value!;
+                return true;
+            case UnaryExpression { NodeType: ExpressionType.Convert } unary when TryEvaluateExpression(unary.Operand, out var operand):
+                value = operand;
+                return true;
+            case MemberExpression member when TryEvaluateMember(member, out var memberValue):
+                value = memberValue;
+                return true;
+            case MethodCallExpression call when TryEvaluateMethodCall(call, out var callResult):
+                value = callResult;
+                return true;
+            default:
+                value = new EvaluationUnavailable($"Unsupported expression: {expression.NodeType}");
+                return false;
+        }
+    }
+
+    static bool TryEvaluateMethodCall(MethodCallExpression call, out object result)
+    {
+        if (!TryEvaluateArguments(call, out var args))
+        {
+            result = new EvaluationUnavailable("Argument evaluation failed");
+            return false;
+        }
+
+        try
+        {
+            object? obj = null;
+            var target = call.Object != null && TryEvaluateExpression(call.Object, out obj) ? obj : null;
+            result = call.Method.Invoke(target, args)!;
+            return true;
+        }
+        catch
+        {
+            result = new EvaluationUnavailable("Method invocation failed");
+            return false;
+        }
+    }
+
+    static bool TryEvaluateArguments(MethodCallExpression call, out object?[] args)
+    {
+        args = new object?[call.Arguments.Count];
+
+        for (var i = 0; i < call.Arguments.Count; i++)
+        {
+            if (!TryEvaluateExpression(call.Arguments[i], out var arg))
+                return false;
+
+            args[i] = arg;
+        }
+
+        return true;
+    }
+
+    static bool TryEvaluateMember(MemberExpression member, out object value)
+    {
+        object? target = null;
+        var hasTarget = member.Expression != null && TryEvaluateExpression(member.Expression, out target);
+
+        if (member.Member is FieldInfo field)
+        {
+            value = field.GetValue(hasTarget ? TargetOrNull(target) : null)!;
+            return true;
+        }
+
+        if (member.Member is PropertyInfo prop)
+        {
+            value = prop.GetValue(hasTarget ? TargetOrNull(target) : null)!;
+            return true;
+        }
+
+        value = new EvaluationUnavailable($"Unsupported member: {member.Member.Name}");
+        return false;
+
+        static object? TargetOrNull(object? targetValue) => targetValue is EvaluationUnavailable ? null : targetValue;
     }
 }

src/SharpAssert.Runtime/Features/Shared/ValueFormatter.cs

@@ -7,6 +7,7 @@ static class ValueFormatter
     public static string Format(object? value) => value switch
     {
         null => "null",
+        EvaluationUnavailable unavailable => unavailable.ToString(),
         string s => $"\"{s}\"",
         DateTime dt => dt.ToString("M/d/yyyy", CultureInfo.InvariantCulture),
         _ => value.ToString()!

src/SharpAssert.Tests/Features/ValueFormatterFixture.cs

@@ -0,0 +1,16 @@
+using FluentAssertions;
+using SharpAssert.Features.Shared;
+
+namespace SharpAssert.Features;
+
+[TestFixture]
+public class ValueFormatterFixture
+{
+    [Test]
+    public void Should_render_unavailable_sentinel()
+    {
+        var unavailable = new EvaluationUnavailable("reason");
+
+        ValueFormatter.Format(unavailable).Should().Be("<unavailable: reason>");
+    }
+}