Make expression value evaluator resilient to missing span ToArray

Author: yevhen

CLAUDE.md

@@ -418,4 +418,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.
 - `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

@@ -129,6 +129,7 @@ This document is organized by topic to consolidate key learnings about the proje
 - **DynamicInvoke Cross-Platform Issues:** Using `Expression.Lambda(expression).Compile().DynamicInvoke()` can fail on CI/certain runtimes with `NotSupportedException: Specified method is not supported` - use strongly-typed `Expression.Lambda<Func<object>>(Expression.Convert(expression, typeof(object))).Compile()()` for direct invocation without reflection
 - **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.
 - **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

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq.Expressions;
 using System.Linq;
 using System.Reflection;
@@ -8,9 +9,7 @@ namespace SharpAssert.Features.Shared;
 
 static class ExpressionValueEvaluator
 {
-    static readonly MethodInfo ToArrayMethod = typeof(MemoryExtensions)
-        .GetMethods(BindingFlags.Public | BindingFlags.Static)
-        .Single(m => m.Name == "ToArray" && m.IsGenericMethodDefinition && m.GetParameters().Length == 1);
+    static readonly MethodInfo? ToArrayMethod = ResolveToArrayMethod();
 
     public static object? Evaluate(Expression expression) => Compile(expression)();
 
@@ -29,6 +28,31 @@ public static Func<object> Compile(Expression expression)
         }
     }
 
+    static MethodInfo? ResolveToArrayMethod()
+    {
+        foreach (var method in typeof(MemoryExtensions).GetMethods(BindingFlags.Public | BindingFlags.Static))
+        {
+            if (method.Name != "ToArray" || !method.IsGenericMethodDefinition)
+                continue;
+
+            var parameters = method.GetParameters();
+            if (parameters.Length != 1)
+                continue;
+
+            if (IsReadOnlySpan(parameters[0].ParameterType))
+                return method;
+        }
+
+        return null;
+    }
+
+    static bool IsReadOnlySpan(Type type)
+    {
+        return type.IsByRefLike &&
+               type.IsGenericType &&
+               type.GetGenericTypeDefinition() == typeof(ReadOnlySpan<>);
+    }
+
     static Expression Normalize(Expression expression)
     {
         if (!expression.Type.IsByRefLike)
@@ -44,6 +68,9 @@ static Expression Normalize(Expression expression)
             ? expression
             : Expression.Convert(expression, readOnlySpanType);
 
+        if (ToArrayMethod == null)
+            return Expression.Constant(null, typeof(object));
+
         var toArray = ToArrayMethod.MakeGenericMethod(elementType);
         var call = Expression.Call(toArray, spanExpression);