Prefer interpreted expression evaluation

Author: yevhen

CLAUDE.md

@@ -420,4 +420,5 @@ async\method: Suffix with `Async` =\> `GetDataAsync()`
 - 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.
+- 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.
 - `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

@@ -131,6 +131,7 @@ This document is organized by topic to consolidate key learnings about the proje
 - **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.
+- **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.
 - **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

@@ -21,18 +21,11 @@ public static Func<object> Compile(Expression expression)
 
         try
         {
-            return lambda.Compile();
+            return lambda.Compile(preferInterpretation: true);
         }
-        catch (Exception ex) when (IsCompileFallbackCase(ex))
+        catch
         {
-            try
-            {
-                return lambda.Compile(preferInterpretation: true);
-            }
-            catch
-            {
-                return NullEvaluator;
-            }
+            return NullEvaluator;
         }
     }
 
@@ -83,13 +76,6 @@ static Expression Normalize(Expression expression)
             return Expression.Convert(call, typeof(object));
         }
 
-        return Expression.Convert(expression, typeof(object));
-    }
-
-    static bool IsCompileFallbackCase(Exception ex)
-    {
-        return ex is InvalidProgramException
-            or TypeLoadException
-            or ArgumentException;
+        return Expression.Constant(null, typeof(object));
     }
 }