Handle .NET 10 MemoryExtensions.Contains overload with comparer

Fixes #37176

Author: roji

src/EFCore/Query/Internal/ParameterExtractingExpressionVisitor.cs

@@ -34,6 +34,9 @@ public class ParameterExtractingExpressionVisitor : ExpressionVisitor
     private static readonly bool UseOldBehavior35100 =
         AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue35100", out var enabled35100) && enabled35100;
 
+    private static readonly bool UseOldBehavior37176 =
+        AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue37176", out var enabled37176) && enabled37176;
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
@@ -210,15 +213,32 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp
             switch (method.Name)
             {
                 case nameof(MemoryExtensions.Contains)
-                    when methodCallExpression.Arguments is [var arg0, var arg1] &&
-                         TryUnwrapSpanImplicitCast(arg0, out var unwrappedArg0):
+                    when UseOldBehavior37176
+                        && methodCallExpression.Arguments is [var arg0, var arg1]
+                        && TryUnwrapSpanImplicitCast(arg0, out var unwrappedArg0):
                 {
                     return Visit(
                         Expression.Call(
                             EnumerableMethods.Contains.MakeGenericMethod(method.GetGenericArguments()[0]),
                             unwrappedArg0, arg1));
                 }
 
+                // In .NET 10, MemoryExtensions.Contains has an overload that accepts a third, optional comparer, in addition to the older
+                // overload that accepts two parameters only.
+                case nameof(MemoryExtensions.Contains)
+                    when !UseOldBehavior37176
+                        && methodCallExpression.Arguments is [var spanArg, var valueArg, ..]
+                        && (methodCallExpression.Arguments.Count is 2
+                            || methodCallExpression.Arguments.Count is 3
+                                && methodCallExpression.Arguments[2] is ConstantExpression { Value: null })
+                        && TryUnwrapSpanImplicitCast(spanArg, out var unwrappedSpanArg):
+                {
+                    return Visit(
+                        Expression.Call(
+                            EnumerableMethods.Contains.MakeGenericMethod(method.GetGenericArguments()[0]),
+                            unwrappedSpanArg, valueArg));
+                }
+
                 case nameof(MemoryExtensions.SequenceEqual)
                     when methodCallExpression.Arguments is [var arg0, var arg1]
                          && TryUnwrapSpanImplicitCast(arg0, out var unwrappedArg0)

test/EFCore.Specification.Tests/Query/PrimitiveCollectionsQueryTestBase.cs

@@ -371,6 +371,34 @@ public virtual Task Column_collection_of_bools_Contains(bool async)
             async,
             ss => ss.Set<PrimitiveCollectionsEntity>().Where(c => c.Bools.Contains(true)));
 
+    // C# 14 first-class spans caused MemoryExtensions.Contains to get resolved instead of Enumerable.Contains.
+    // The following tests that the various overloads are all supported.
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual Task Contains_on_Enumerable(bool async)
+        => AssertQuery(
+            async,
+            ss => ss.Set<PrimitiveCollectionsEntity>().Where(c => Enumerable.Contains(new[] { 10, 999 }, c.Int)));
+
+    // C# 14 first-class spans caused MemoryExtensions.Contains to get resolved instead of Enumerable.Contains.
+    // The following tests that the various overloads are all supported.
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual Task Contains_on_MemoryExtensions(bool async)
+        => AssertQuery(
+            async,
+            ss => ss.Set<PrimitiveCollectionsEntity>().Where(c => MemoryExtensions.Contains(new[] { 10, 999 }, c.Int)));
+
+    // Note that we don't test EF 8/9 with .NET 10; this test is here for completeness/documentation purposes.
+#if NET10_0_OR_GREATER
+    [ConditionalTheory]
+    [MemberData(nameof(IsAsyncData))]
+    public virtual Task Contains_with_MemoryExtensions_with_null_comparer(bool async)
+        => AssertQuery(
+            async,
+            ss => ss.Set<PrimitiveCollectionsEntity>().Where(c => MemoryExtensions.Contains(new[] { 10, 999 }, c.Int, comparer: null)));
+#endif
+
     [ConditionalTheory]
     [MemberData(nameof(IsAsyncData))]
     public virtual Task Column_collection_Count_method(bool async)