CSHARP-2557: Fix bug in '$elemMatch' generating if expression predicate contains DocumentsExpressions as an operand.

Author: DmitryLukyanov

src/MongoDB.Driver/Linq/Translators/PredicateTranslator.cs

@@ -217,6 +217,32 @@ private bool CanAnyBeRenderedWithoutElemMatch(Expression node)
             }
         }
 
+        private FilterDefinition<BsonDocument> ConvertElemMatchFilterToScalarElementMatchIfNeeded(FilterDefinition<BsonDocument> filter, IFieldExpression fieldExpression, Expression wherePredicate)
+        {
+            if ((!(fieldExpression.Serializer is IBsonDocumentSerializer)) || DoesExpressionUseDocumentItself(wherePredicate))
+            {
+                return new ScalarElementMatchFilterDefinition<BsonDocument>(filter);
+            }
+            else
+            {
+                return filter;
+            }
+        }
+
+        private bool DoesExpressionUseDocumentItself(Expression node)
+        {
+            // if a left operand is DocumentExpression, we need to generate a "$elemMatch" in a short form,
+            // otherwise we will have $elemMatch queries with gaps similar to : "{ $elemMatch : { ' ' : {"
+            if (node is BinaryExpression binaryExpression)
+            {
+                if (binaryExpression.Left is DocumentExpression)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
         private FilterDefinition<BsonDocument> TranslateArrayLength(Expression variableNode, ExpressionType operatorType, ConstantExpression constantNode)
         {
             var allowedOperators = new[]
@@ -935,10 +961,8 @@ private FilterDefinition<BsonDocument> TranslatePipelineAny(PipelineExpression n
             {
                 var predicate = DocumentToFieldConverter.Convert(whereExpression.Predicate);
                 filter = __builder.ElemMatch(fieldExpression.FieldName, Translate(predicate));
-                if (!(fieldExpression.Serializer is IBsonDocumentSerializer))
-                {
-                    filter = new ScalarElementMatchFilterDefinition<BsonDocument>(filter);
-                }
+
+                filter = ConvertElemMatchFilterToScalarElementMatchIfNeeded(filter, fieldExpression, whereExpression.Predicate);
             }
 
             return filter;

tests/MongoDB.Driver.Tests/Linq/IntegrationTestBase.cs

@@ -16,7 +16,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
+using MongoDB.Bson;
 using MongoDB.Bson.Serialization.Attributes;
 
 namespace MongoDB.Driver.Tests.Linq
@@ -101,7 +101,8 @@ private void InsertFirst()
                                     {
                                         D = "Delilah"
                                     }
-                            }
+                            },
+                            Ids = new [] { new ObjectId("111111111111111111111111") }
                         },
                         new C
                         {
@@ -251,6 +252,8 @@ public class RootDescended : Root
 
         public class C
         {
+            public IEnumerable<ObjectId> Ids { get; set; }
+
             public string D { get; set; }
 
             public E E { get; set; }

tests/MongoDB.Driver.Tests/Linq/Translators/PredicateTranslatorTests.cs

@@ -120,6 +120,56 @@ public void Any_with_a_predicate_on_documents()
                 "{ G : { $elemMatch : { D : \"Don't\", 'E.F' : 33 } } }");
         }
 
+        [Fact]
+        public void Any_with_a_predicate_on_document_itself()
+        {
+            Assert(
+                x => x.G.Any(g => g != null),
+                2,
+                "{ 'G' : { '$elemMatch' : { '$ne' : null } } }");
+
+            Assert(
+                x => x.G.Any(g => null != g),
+                2,
+                "{ 'G' : { '$elemMatch' : { '$ne' : null } } }");
+
+            Assert(
+                x => x.G.Any(g => g.E.I.Any(i => i == "insecure")),
+                1,
+                "{ \"G.E.I\" : { '$elemMatch' : { '$eq': 'insecure' } } }");
+        }
+
+        [Fact]
+        public void Any_with_a_predicate_on_document_itself_and_objectId()
+        {
+            Assert(
+                x => x.G.Any(g => g.Ids.Any(i => i == ObjectId.Parse("111111111111111111111111"))),
+                1,
+                "{ 'G.Ids' : { '$elemMatch' : { '$eq' : ObjectId('111111111111111111111111') } } }");
+        }
+
+        [Fact]
+        public void Any_with_a_predicate_on_documents_itself_and_ClassEquals()
+        {
+            var c1 = new C()
+            {
+                D = "Dolphin",
+                E = new E()
+                {
+                    F = 55,
+                    H = 66,
+                    I = new List<string>()
+                    {
+                        "insecure"
+                    }
+                }
+            };
+            Assert(
+                x => x.G.Any(g => g == c1),
+                1,
+                "{ \"G\" : { \"$elemMatch\" : { \"Ids\" : null, \"D\" : \"Dolphin\", \"E\" : { \"F\" : 55, \"H\" : 66, \"I\" : [\"insecure\"] }, \"S\" : null, \"X\" : null } } }");
+        }
+
         [Fact]
         public void Any_with_a_gte_predicate_on_documents()
         {
@@ -585,7 +635,7 @@ public void ClassEquals()
             Assert(
                 x => x.C == new C { D = "Dexter" },
                 0,
-                "{C: {D: 'Dexter', E: null, S: null, X: null}}");
+                "{ C : { Ids : null, D : 'Dexter', E : null, S : null, X : null } }");
         }
 
         [Fact]
@@ -594,7 +644,7 @@ public void ClassEqualsMethod()
             Assert(
                 x => x.C.Equals(new C { D = "Dexter" }),
                 0,
-                "{C: {D: 'Dexter', E: null, S: null, X: null}}");
+                "{ C : { Ids : null, D : 'Dexter', E : null, S : null, X : null } }");
         }
 
         [Fact]
@@ -603,7 +653,7 @@ public void ClassNotEquals()
             Assert(
                 x => x.C != new C { D = "Dexter" },
                 2,
-                "{C: {$ne: {D: 'Dexter', E: null, S: null, X: null}}}");
+                "{ C : { $ne : { Ids : null, D : 'Dexter', E : null, S : null, X : null } } }");
         }
 
         [Fact]

tests/MongoDB.Driver.Tests/Linq/Translators/PredicateValueConversionTests.cs

@@ -46,7 +46,7 @@ public void Value_conversion_with_custom_type_converter()
             Assert(
                 x => x.C == objectToConvert,
                 0,
-                "{ C : { D : 'Dexter', E : null, S : null, X : null } }");
+                "{ C : { Ids : null, D : 'Dexter', E : null, S : null, X : null } }");
         }
 
         public void Assert(Expression<Func<Root, bool>> filter, int expectedCount, string expectedFilter)