CSHARP-2705: Linq Translation of Nested Any throws NotSupportedException.

Author: DmitryLukyanov

src/MongoDB.Driver/Linq/Processors/OutOfCurrentScopePrefixCollector.cs

@@ -24,6 +24,7 @@ namespace MongoDB.Driver.Linq.Processors
     /// </summary>
     internal sealed class OutOfCurrentScopePrefixCollector : ExtensionExpressionVisitor
     {
+        private bool _isWhereSourceConstantExpression = false;
         private readonly HashSet<string> _outOfCurrentScopePrefixCollection = new HashSet<string>();
 
         /// <summary>
@@ -41,12 +42,25 @@ public static IEnumerable<string> Collect(Expression expression)
         public override Expression Visit(Expression node)
         {
             var hasOutOfCurrentScopePrefix = node as IHasOutOfCurrentScopePrefix;
-            if (hasOutOfCurrentScopePrefix != null && !string.IsNullOrWhiteSpace(hasOutOfCurrentScopePrefix.OutOfCurrentScopePrefix))
+            if (hasOutOfCurrentScopePrefix != null &&
+                !string.IsNullOrWhiteSpace(hasOutOfCurrentScopePrefix.OutOfCurrentScopePrefix) &&
+                !_isWhereSourceConstantExpression)
             {
                 _outOfCurrentScopePrefixCollection.Add(hasOutOfCurrentScopePrefix.OutOfCurrentScopePrefix);
             }
 
             return base.Visit(node);
         }
+
+        protected internal override Expression VisitWhere(WhereExpression node)
+        {
+            if (node.Source.NodeType == ExpressionType.Constant)
+            {
+                _isWhereSourceConstantExpression = true;
+            }
+            var result = base.VisitWhere(node);
+            _isWhereSourceConstantExpression = false;
+            return result;
+        }
     }
 }

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

@@ -59,6 +59,75 @@ public void Should_not_throw_the_exception_when_a_child_expression_is_called_fro
             Execute(CreateWhereQuery(expr));
         }
 
+        [Fact]
+        public void Should_not_throw_the_exception_when_a_child_expression_is_called_from_nested_locals()
+        {
+            Setup();
+
+            var local = new List<int> { 1, 2 };
+            var local2 = new List<bool> { true, false };
+
+            Expression<Func<TestObject, bool>> expr = (a) => a.Collection1.Any(b => local.Any(c => b.Collection2.Contains(c)));
+            AssertWhere(expr, "{ $match : { 'Collection2' : { '$in' : [1, 2] } } }");
+
+            expr = (a) => a.Collection1.Any(b => b.Collection1.Any(c => local.Any(d => c.Collection2.Contains(d))));
+            AssertWhere(expr, "{ $match : { 'Collection2' : { '$in' : [1, 2] } } }");
+
+            expr = (a) => a.Collection1.Any(b => b.Collection2 != null && b.Collection1.Any(c => local.Any(d => c.Collection2.Contains(d))));
+            AssertWhere(expr, "{ $match : { 'Collection1' : { '$elemMatch' : { 'Collection2' : { '$ne' : null, '$in' : [1, 2] } } } } }");
+
+            expr = (a) => a.Collection1.Any(
+                b =>
+                    b.Collection1 != null && b.Collection1.Any(
+                        c =>
+                            local.Any(d => c.Collection2.Contains(d)) &&
+                            local2.Any(e => c.Collection3.Contains(e))
+                        ));
+            AssertWhere(
+                expr,
+                @"{ 
+                    $match : { 
+                        'Collection1' : { 
+                            '$elemMatch' : { 
+                                'Collection1' : { 
+                                    '$ne' : null, 
+                                    '$elemMatch' : { 
+                                        'Collection2' : { '$in' : [1, 2] }, 
+                                        'Collection3' : { '$in' : [true, false] } 
+                                    } 
+                                } 
+                            } 
+                        } 
+                    }
+                }");
+
+            expr = (a) => a.Collection1.Any(
+                b =>
+                    b.Collection1 != null && b.Collection1.Any(
+                        c =>
+                            c.Collection1.Any(d => d.Value1 == 2) &&
+                            local2.Any(e => c.Collection3.Contains(e))
+                        ));
+            AssertWhere(
+                expr, 
+                @"
+                {
+                    $match : { 
+                        'Collection1' : { 
+                            '$elemMatch' : { 
+                                'Collection1' : { 
+                                    '$ne' : null, 
+                                    '$elemMatch' : { 
+                                        'Collection1' : { '$elemMatch' : { 'Value1' : 2 } }, 
+                                        'Collection3' : { '$in' : [true, false] } 
+                                    } 
+                                } 
+                            } 
+                        }
+                    }
+                }");
+        }
+
         [Fact]
         public void Should_not_throw_the_exception_when_a_predicate_has_only_parameter_expressions()
         {
@@ -175,6 +244,21 @@ public void Should_throw_the_exception_when_there_is_the_parent_parameter_in_the
             exception.Message.Should().Be(string.Format(NotSupportErrorMessageTemplate, "{document}{Collection1}.Where((({document}{Value1} != 3) AndAlso Any({document}{Collection1}.Where(({document}{Value1} != 5)))))", "a"));
         }
 
+        // private methods
+        private void AssertWhere(Expression<Func<TestObject, bool>> expression, string expectedStages)
+        {
+            var actualStages = Execute(CreateWhereQuery(expression));
+            var actual = new BsonDocument();
+            foreach (var actualStage in actualStages)
+            {
+                actual.AddRange(actualStage);
+            }
+
+            var expected = BsonDocument.Parse(expectedStages);
+
+            actual.Should().Be(expected);
+        }
+
         private IEnumerable<BsonDocument> Execute<T>(IMongoQueryable<T> queryable)
         {
             var result = (AggregateQueryableExecutionModel<T>)queryable.GetExecutionModel();