Process Span<>/ReadOnlySpan<>/.Contains() cases in LINQ Expression

.github/workflows/test-sql.yaml

@@ -19,7 +19,8 @@ jobs:
           timezoneLinux: "UTC"
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
-        with: { dotnet-version: 9 }
+        with:
+          dotnet-version: 9.x
       - name: Setup MSSQL Tools
         uses:  rails-sqlserver/setup-mssql@v1
         with:

Orm/Xtensive.Orm.Tests/Linq/InTest.cs

@@ -657,5 +657,18 @@ where track.Name.In(IncludeAlgorithm.TableValuedParameter, names)
           select track
         ).ToList();
     }
+
+    // Related to https://github.com/DataObjects-NET/dataobjects-net/issues/402
+    [Test]
+    public void ReadOnlySpanContains_Test()
+    {
+      var result = ReadOnlySpanContains_GetCustomers(["Michelle", "Jack"]);
+      Assert.AreEqual(2, result.Count);
+      Assert.IsTrue(result.Contains("Michelle"));
+      Assert.IsTrue(result.Contains("Jack"));
+    }
+
+    private List<string> ReadOnlySpanContains_GetCustomers(string[] customerNames) =>
+      (from c in Session.Query.All<Customer>() where MemoryExtensions.Contains(customerNames, c.FirstName) select c.FirstName).ToList();
   }
 }

Orm/Xtensive.Orm/Orm/Linq/ExpressionExtensions.cs

@@ -77,7 +77,9 @@ public static bool IsLocalCollection(this Expression expression, TranslatorConte
                var expressionType => !IsEntitySet(expressionType)
                                      && !expression.IsSubqueryExpression()
                                      && expressionType != WellKnownTypes.String
-                                     && expressionType.IsOfGenericInterface(WellKnownInterfaces.EnumerableOfT)
+                                     && (expressionType.IsOfGenericInterface(WellKnownInterfaces.EnumerableOfT)
+                                        || expressionType.IsOfGenericType(WellKnownTypes.ReadOnlySpanOfT)
+                                        || expressionType.IsOfGenericType(WellKnownTypes.SpanOfT))
                                      && (IsEvaluableCollection(context, expression, expressionType) ||
                                          IsForeignQuery(expression))
              };
@@ -203,4 +205,4 @@ public static ParameterInfo[] GetConstructorParameters(this NewExpression expres
       return expression.Constructor.GetParameters();
     }
   }
-}
+}

Orm/Xtensive.Orm/Orm/Linq/QueryHelper.cs

@@ -202,7 +202,8 @@ public static void TryAddConvarianceCast(ref Expression source, Type baseType)
 
     public static Type GetSequenceElementType(Type type)
     {
-      var sequenceType = type.GetGenericInterface(WellKnownInterfaces.EnumerableOfT);
+      var sequenceType = type.GetGenericInterface(WellKnownInterfaces.EnumerableOfT)
+        ?? (type.IsOfGenericType(WellKnownTypes.ReadOnlySpanOfT) || type.IsOfGenericType(WellKnownTypes.SpanOfT) ? type : null);
       return sequenceType?.GetGenericArguments()[0];
     }
 

Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs

@@ -541,15 +541,20 @@ protected override Expression VisitMethodCall(MethodCallExpression mc)
           }
         }
 
-
         // Process local collections
-        if (mc.Object.IsLocalCollection(context)) {
-          // IList.Contains
-          // List.Contains
-          // Array.Contains
-          var parameters = method.GetParameters();
-          if (methodName == nameof(ICollection<int>.Contains) && parameters.Length == 1)
-            return VisitContains(mc.Object, mc.Arguments[0], false);
+        if (methodName == nameof(ICollection<int>.Contains)) {
+          if (mc.Object.IsLocalCollection(context)) {
+            // IList.Contains
+            // List.Contains
+            // Array.Contains
+            var parameters = method.GetParameters();
+            if (parameters.Length == 1)
+              return VisitContains(mc.Object, mc.Arguments[0], false);
+          }
+          else if (methodDeclaringType == typeof(MemoryExtensions)) {
+            // ReadOnlySpan<>.Contains
+            return VisitContains(mc.Arguments[0], mc.Arguments[1], false);
+          }
         }
 
         var result = base.VisitMethodCall(mc);

Orm/Xtensive.Orm/Orm/Linq/Translator.Queryable.cs

@@ -1767,9 +1767,16 @@ private ProjectionExpression VisitSequence(Expression sequenceExpression, Expres
         string.Format(Strings.ExExpressionXIsNotASequence, expressionPart.ToString(true)));
     }
 
-    private ProjectionExpression VisitLocalCollectionSequence<TItem>(Expression sequence) =>
-      CreateLocalCollectionProjectionExpression(typeof(TItem), ParameterAccessorFactory.CreateAccessorExpression<IEnumerable<TItem>>(
+    private ProjectionExpression VisitLocalCollectionSequence<TItem>(Expression sequence)
+    {
+      var type = sequence.Type;
+      if (type.IsOfGenericType(WellKnownTypes.ReadOnlySpanOfT) || type.IsOfGenericType(WellKnownTypes.SpanOfT)) {
+        sequence = Expression.Call(sequence, type.GetMethod("ToArray"));
+      }
+
+      return CreateLocalCollectionProjectionExpression(typeof(TItem), ParameterAccessorFactory.CreateAccessorExpression<IEnumerable<TItem>>(
         compiledQueryScope is not null ? compiledQueryScope.QueryParameterReplacer.Replace(sequence) : sequence).CachingCompile(), this, sequence);
+    }
 
     private Expression VisitContainsAny(Expression setA, Expression setB, bool isRoot, Type elementType)
     {

Orm/Xtensive.Orm/Reflection/WellKnownTypes.cs

@@ -81,5 +81,8 @@ internal static class WellKnownTypes
     public static readonly Type ObjectArray = typeof(object[]);
 
     public static readonly Type DefaultMemberAttribute = typeof(DefaultMemberAttribute);
+
+    public static readonly Type ReadOnlySpanOfT = typeof(ReadOnlySpan<>);
+    public static readonly Type SpanOfT = typeof(Span<>);
   }
-}
+}