Add explicit handling for collection Contains filters in LINQ expressions

Enhance GoogleTextSearch LINQ filter processing to explicitly detect and reject collection Contains operations (e.g., array.Contains(page.Property)) with a clear, actionable error message.

Changes:
- Added IsMemoryExtensionsContains helper method to detect C# 14+ span-based Contains resolution
- Enhanced TryProcessSingleExpression to distinguish between:
  * String.Contains (supported for substring search)
  * Enumerable.Contains / MemoryExtensions.Contains (not supported - now explicitly rejected)
- Throws NotSupportedException with guidance on alternatives when collection Contains is detected
- Handles both C# 13- (Enumerable.Contains) and C# 14+ (MemoryExtensions.Contains) resolution paths

Test Coverage:
- Added CollectionContainsFilterThrowsNotSupportedExceptionAsync test
- Verifies exception is thrown for collection Contains operations
- Validates error message contains actionable guidance about OR logic limitations
- Ensures consistent behavior across C# language versions (13 vs 14 Contains resolution)

Rationale:
Google Custom Search API does not support OR logic across multiple values. Collection Contains filters would require OR semantics that cannot be expressed via Google's query parameters. This change provides clear, early feedback to developers attempting to use unsupported filter patterns.

Related to reviewer feedback on LINQ expression filter validation and C# 14 compatibility. Fixes #10456

Author: alzarei

dotnet/src/Plugins/Plugins.UnitTests/Web/Google/GoogleTextSearchTests.cs

@@ -700,6 +700,35 @@ await textSearch.SearchAsync("test",
         Assert.Contains("excludeTerms=deprecated", absoluteUri);
     }
 
+    [Fact]
+    public async Task CollectionContainsFilterThrowsNotSupportedExceptionAsync()
+    {
+        // Arrange
+        using var textSearch = new GoogleTextSearch(
+            initializer: new() { ApiKey = "ApiKey", HttpClientFactory = this._clientFactory },
+            searchEngineId: "SearchEngineId");
+
+        // Act & Assert - Collection Contains (both Enumerable.Contains and MemoryExtensions.Contains)
+        // This same code resolves differently based on C# language version:
+        // - C# 13 and earlier: Enumerable.Contains (LINQ extension method)
+        // - C# 14 and later: MemoryExtensions.Contains (span-based optimization)
+        // Our implementation handles both identically - both throw NotSupportedException
+        string[] sites = ["microsoft.com", "github.com"];
+        var exception = await Assert.ThrowsAsync<NotSupportedException>(async () =>
+            await textSearch.SearchAsync("test",
+                new TextSearchOptions<GoogleWebPage>
+                {
+                    Top = 4,
+                    Skip = 0,
+                    Filter = page => sites.Contains(page.DisplayLink!)
+                }));
+
+        // Verify exception message is clear and actionable
+        Assert.Contains("Collection Contains filters", exception.Message);
+        Assert.Contains("not supported by Google Custom Search API", exception.Message);
+        Assert.Contains("OR logic", exception.Message);
+    }
+
     #endregion
 
     /// <inheritdoc/>

dotnet/src/Plugins/Plugins.Web/Google/GoogleTextSearch.cs

@@ -222,12 +222,31 @@ private static bool TryProcessSingleExpression(Expression expression, TextSearch
             return TryProcessInequalityExpression(notEqualExpr, filter);
         }
 
-        // Handle string Contains: record.PropertyName.Contains("value")
-        if (expression is MethodCallExpression methodCall &&
-            methodCall.Method.Name == "Contains" &&
-            methodCall.Method.DeclaringType == typeof(string))
+        // Handle Contains method calls
+        if (expression is MethodCallExpression methodCall && methodCall.Method.Name == "Contains")
         {
-            return TryProcessContainsExpression(methodCall, filter);
+            // String.Contains (instance method) - supported for substring search
+            if (methodCall.Method.DeclaringType == typeof(string))
+            {
+                return TryProcessContainsExpression(methodCall, filter);
+            }
+
+            // Collection Contains (static methods) - NOT supported due to Google API limitations
+            // This handles both Enumerable.Contains (C# 13-) and MemoryExtensions.Contains (C# 14+)
+            // User's C# language version determines which method is resolved, but both are unsupported
+            if (methodCall.Object == null) // Static method
+            {
+                // Enumerable.Contains or MemoryExtensions.Contains
+                if (methodCall.Method.DeclaringType == typeof(Enumerable) ||
+                    (methodCall.Method.DeclaringType == typeof(MemoryExtensions) && IsMemoryExtensionsContains(methodCall)))
+                {
+                    throw new NotSupportedException(
+                        "Collection Contains filters (e.g., array.Contains(page.Property)) are not supported by Google Custom Search API. " +
+                        "Google's search operators do not support OR logic across multiple values. " +
+                        "Consider either: (1) performing multiple separate searches for each value, or " +
+                        "(2) retrieving broader results and filtering on the client side.");
+                }
+            }
         }
 
         // Handle NOT expressions: !record.PropertyName.Contains("value")
@@ -239,6 +258,22 @@ private static bool TryProcessSingleExpression(Expression expression, TextSearch
         return false;
     }
 
+    /// <summary>
+    /// Checks if a method call expression is MemoryExtensions.Contains.
+    /// This handles C# 14's "first-class spans" feature where collection.Contains(item) resolves to
+    /// MemoryExtensions.Contains instead of Enumerable.Contains.
+    /// </summary>
+    private static bool IsMemoryExtensionsContains(MethodCallExpression methodExpr)
+    {
+        // MemoryExtensions.Contains has 2-3 parameters (source, value, optional comparer)
+        // We only support the case without a comparer (or with null comparer)
+        return methodExpr.Method.Name == nameof(MemoryExtensions.Contains) &&
+               methodExpr.Arguments.Count >= 2 &&
+               methodExpr.Arguments.Count <= 3 &&
+               (methodExpr.Arguments.Count == 2 ||
+                (methodExpr.Arguments.Count == 3 && methodExpr.Arguments[2] is ConstantExpression { Value: null }));
+    }
+
     /// <summary>
     /// Processes equality expressions: record.PropertyName == "value"
     /// </summary>