Broaden expression eval fallback and remove warnings

Author: yevhen

CLAUDE.md

@@ -419,4 +419,5 @@ async\method: Suffix with `Async` =\> `GetDataAsync()`
 - Expression compilation can emit invalid IL on some runtimes; fall back to `Compile(preferInterpretation: true)` when evaluating expressions to avoid CI-only `InvalidProgramException`.
 - Byref-like expression trees (e.g., `Span<T>`, `ReadOnlySpan<T>`) cannot be boxed; convert them to arrays before evaluation to avoid interpreter type load errors.
 - 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.
 - `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

@@ -130,6 +130,7 @@ This document is organized by topic to consolidate key learnings about the proje
 - **Expression.Compile InvalidProgramException:** Expression compilation can emit invalid IL on some runtimes; prefer `Compile(preferInterpretation: true)` or catch `InvalidProgramException` and recompile in interpreted mode to ensure value extraction works on CI
 - **ByRef-like expression evaluation:** Ref structs (e.g., `Span<T>`, `ReadOnlySpan<T>`) cannot be boxed to `object`; convert them to arrays (e.g., `MemoryExtensions.ToArray`) before value extraction to avoid interpreter `TypeLoadException`/`ArgumentException`.
 - **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.
 - **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/Shared/ExpressionValueEvaluator.cs

@@ -10,6 +10,7 @@ namespace SharpAssert.Features.Shared;
 static class ExpressionValueEvaluator
 {
     static readonly MethodInfo? ToArrayMethod = ResolveToArrayMethod();
+    static readonly Func<object> NullEvaluator = () => null!;
 
     public static object? Evaluate(Expression expression) => Compile(expression)();
 
@@ -22,9 +23,16 @@ public static Func<object> Compile(Expression expression)
         {
             return lambda.Compile();
         }
-        catch (InvalidProgramException)
+        catch (Exception ex) when (IsCompileFallbackCase(ex))
         {
-            return lambda.Compile(preferInterpretation: true);
+            try
+            {
+                return lambda.Compile(preferInterpretation: true);
+            }
+            catch
+            {
+                return NullEvaluator;
+            }
         }
     }
 
@@ -68,12 +76,20 @@ static Expression Normalize(Expression expression)
             ? expression
             : Expression.Convert(expression, readOnlySpanType);
 
-        if (ToArrayMethod == null)
-            return Expression.Constant(null, typeof(object));
+        if (ToArrayMethod != null)
+        {
+            var toArray = ToArrayMethod.MakeGenericMethod(elementType);
+            var call = Expression.Call(toArray, spanExpression);
+            return Expression.Convert(call, typeof(object));
+        }
 
-        var toArray = ToArrayMethod.MakeGenericMethod(elementType);
-        var call = Expression.Call(toArray, spanExpression);
+        return Expression.Convert(expression, typeof(object));
+    }
 
-        return Expression.Convert(call, typeof(object));
+    static bool IsCompileFallbackCase(Exception ex)
+    {
+        return ex is InvalidProgramException
+            or TypeLoadException
+            or ArgumentException;
     }
 }