Entity equality support for non-extension Contains

EE handled the extension version of {IQueryable,IEnumerable}.Contains,
but not instance methods such as List.Contains.

Fixes #15554

src/EFCore/Query/Internal/EntityEqualityRewritingExpressionVisitor.cs

@@ -187,6 +187,15 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp
  }
  }
 
+ // We handled the Contains extension method above, but there's also List.Contains and potentially others on ICollection
+ if (methodCallExpression.Method.Name == "Contains"
+ && methodCallExpression.Method.ReturnType == typeof(bool)
+ && methodCallExpression.Arguments.Count == 1
+ && methodCallExpression.Object?.Type.TryGetSequenceType() == methodCallExpression.Arguments[0].Type)
+ {
+ return VisitContainsMethodCall(methodCallExpression);
+ }
+
  // TODO: Can add an extension point that can be overridden by subclassing visitors to recognize additional methods and flow through the entity type.
  // Do this here, since below we visit the arguments (avoid double visitation)
 
@@ -258,16 +267,17 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp
 
  protected virtual Expression VisitContainsMethodCall(MethodCallExpression methodCallExpression)
  {
- var arguments = methodCallExpression.Arguments;
- var newSource = Visit(arguments[0]);
- var newItem = Visit(arguments[1]);
+ // We handle both Contains the extension method and the instance method
+ var (newSource, newItem) = methodCallExpression.Arguments.Count == 2
+ ? (Visit(methodCallExpression.Arguments[0]), Visit(methodCallExpression.Arguments[1]))
+ : (Visit(methodCallExpression.Object), Visit(methodCallExpression.Arguments[0]));
 
  var sourceEntityType = (newSource as EntityReferenceExpression)?.EntityType;
  var itemEntityType = (newItem as EntityReferenceExpression)?.EntityType;
 
  if (sourceEntityType == null && itemEntityType == null)
  {
- return methodCallExpression.Update(null, new[] { newSource, newItem });
+ return NoTranslation();
  }
 
  if (sourceEntityType != null && itemEntityType != null
@@ -280,15 +290,22 @@ protected virtual Expression VisitContainsMethodCall(MethodCallExpression method
  var entityType = sourceEntityType ?? itemEntityType;
 
  var keyProperties = entityType.FindPrimaryKey().Properties;
- var keyProperty = keyProperties.Count == 1
- ? keyProperties.Single()
- : throw new NotSupportedException(CoreStrings.EntityEqualityContainsWithCompositeKeyNotSupported(entityType.DisplayName()));
+ if (keyProperties.Count > 1)
+ {
+ // We usually throw on composite keys, but here specifically we don't in order to allow Any(Contains()) to be translated
+ // by nav expansion (see test Where_contains_on_navigation_with_composite_keys)
+ return NoTranslation();
+ }
+ var keyProperty = keyProperties.Single();
 
  // Wrap the source with a projection to its primary key, and the item with a primary key access expression
+ var isQueryable = Unwrap(newSource).Type.IsQueryableType();
  var param = Expression.Parameter(entityType.ClrType, "v");
  var keySelector = Expression.Lambda(CreatePropertyAccessExpression(param, keyProperty), param);
  var keyProjection = Expression.Call(
- LinqMethodHelpers.QueryableSelectMethodInfo.MakeGenericMethod(entityType.ClrType, keyProperty.ClrType),
+ (isQueryable
+ ? LinqMethodHelpers.QueryableSelectMethodInfo
+ : LinqMethodHelpers.EnumerableSelectMethodInfo).MakeGenericMethod(entityType.ClrType, keyProperty.ClrType),
  Unwrap(newSource),
  keySelector);
 
@@ -297,10 +314,16 @@ protected virtual Expression VisitContainsMethodCall(MethodCallExpression method
  : CreatePropertyAccessExpression(Unwrap(newItem), keyProperty);
 
  return Expression.Call(
- LinqMethodHelpers.QueryableContainsMethodInfo.MakeGenericMethod(keyProperty.ClrType),
+ (isQueryable
+ ? LinqMethodHelpers.QueryableContainsMethodInfo
+ : LinqMethodHelpers.EnumerableContainsMethodInfo).MakeGenericMethod(keyProperty.ClrType),
  keyProjection,
  rewrittenItem
  );
+
+ Expression NoTranslation() => methodCallExpression.Arguments.Count == 2
+ ? methodCallExpression.Update(null, new[] { Unwrap(newSource), Unwrap(newItem) })
+ : methodCallExpression.Update(Unwrap(newSource), new[] { Unwrap(newItem) });
  }
 
  protected virtual Expression VisitOrderingMethodCall(MethodCallExpression methodCallExpression)

test/EFCore.Cosmos.FunctionalTests/Query/SimpleQueryCosmosTest.ResultOperators.cs

@@ -1207,6 +1207,17 @@ FROM root c
 WHERE ((c[""Discriminator""] = ""Order"") AND (c[""OrderID""] = 10248))");
  }
 
+ [ConditionalTheory(Skip = "Issue#14935 (Contains not implemented)")]
+ public override void List_Contains_over_entityType_should_rewrite_to_identity_equality(bool isAsync)
+ {
+ base.List_Contains_over_entityType_should_rewrite_to_identity_equality(isAsync);
+
+ AssertSql(
+ @"SELECT c
+FROM root c
+WHERE ((c[""Discriminator""] = ""Order"") AND (c[""OrderID""] = 10248))");
+ }
+
  [ConditionalTheory(Skip = "Issue#14935 (Contains not implemented)")]
  public override void Contains_over_entityType_with_null_should_rewrite_to_identity_equality()
  {

test/EFCore.Specification.Tests/Query/SimpleQueryTestBase.ResultOperators.cs

@@ -1510,6 +1510,17 @@ var query
  }
  }
 
+ [ConditionalTheory]
+ [MemberData(nameof(IsAsyncData))]
+ public virtual Task List_Contains_over_entityType_should_rewrite_to_identity_equality(bool isAsync)
+ {
+ var someOrder = new Order { OrderID = 10248 };
+
+ return AssertQuery<Customer>(isAsync, cs =>
+ cs.Where(c => c.Orders.Contains(someOrder)),
+ entryCount: 1);
+ }
+
  [ConditionalFact]
  public virtual void Contains_over_entityType_with_null_should_rewrite_to_identity_equality()
  {

test/EFCore.SqlServer.FunctionalTests/Query/SimpleQuerySqlServerTest.ResultOperators.cs

@@ -1196,6 +1196,22 @@ ELSE CAST(0 AS bit)
 END");
  }
 
+ public override async Task List_Contains_over_entityType_should_rewrite_to_identity_equality(bool isAsync)
+ {
+ await base.List_Contains_over_entityType_should_rewrite_to_identity_equality(isAsync);
+
+ AssertSql(
+ @"@__entity_equality_someOrder_0_OrderID='10248'
+
+SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region]
+FROM [Customers] AS [c]
+WHERE @__entity_equality_someOrder_0_OrderID IN (
+ SELECT [o].[OrderID]
+ FROM [Orders] AS [o]
+ WHERE ([c].[CustomerID] = [o].[CustomerID]) AND [o].[CustomerID] IS NOT NULL
+)");
+ }
+
  public override void Contains_over_entityType_with_null_should_rewrite_to_identity_equality()
  {
  base.Contains_over_entityType_with_null_should_rewrite_to_identity_equality();

test/EFCore.SqlServer.FunctionalTests/Query/SimpleQuerySqlServerTest.Where.cs

@@ -1717,10 +1717,12 @@ FROM [Orders] AS [o]
 WHERE EXISTS (
  SELECT 1
  FROM [Customers] AS [c]
- WHERE EXISTS (
- SELECT 1
+ WHERE [o].[OrderID] IN (
+ SELECT [o0].[OrderID]
  FROM [Orders] AS [o0]
- WHERE (([c].[CustomerID] = [o0].[CustomerID]) AND [o0].[CustomerID] IS NOT NULL) AND ([o0].[OrderID] = [o].[OrderID])))");
+ WHERE ([c].[CustomerID] = [o0].[CustomerID]) AND [o0].[CustomerID] IS NOT NULL
+ )
+)");
  }
 
  public override async Task Where_subquery_FirstOrDefault_is_null(bool isAsync)