CSHARP-4859: Nested AsQueryable.

Author: rstam

src/MongoDB.Driver/Linq/Linq3Implementation/Misc/ExpressionHelper.cs

@@ -13,7 +13,9 @@
 * limitations under the License.
 */
 
+using System.Linq;
 using System.Linq.Expressions;
+using System.Reflection;
 using MongoDB.Driver.Core.Misc;
 
 namespace MongoDB.Driver.Linq.Linq3Implementation.Misc
@@ -27,5 +29,20 @@ public static LambdaExpression UnquoteLambda(Expression expression)
             var unaryExpression = (UnaryExpression)expression;
             return (LambdaExpression)unaryExpression.Operand;
         }
+
+        public static LambdaExpression UnquoteLambdaIfQueryableMethod(MethodInfo method, Expression expression)
+        {
+            Ensure.IsNotNull(method, nameof(method));
+            Ensure.IsNotNull(expression, nameof(expression));
+
+            if (method.DeclaringType == typeof(Queryable))
+            {
+                return UnquoteLambda(expression);
+            }
+            else
+            {
+                return (LambdaExpression)expression;
+            }
+        }
     }
 }

src/MongoDB.Driver/Linq/Linq3Implementation/Misc/NestedAsQueryableHelper.cs

@@ -0,0 +1,43 @@
+/* Copyright 2010-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System.Linq;
+using System.Linq.Expressions;
+using MongoDB.Driver.Linq.Linq3Implementation.Serializers;
+using MongoDB.Driver.Linq.Linq3Implementation.Translators.ExpressionToAggregationExpressionTranslators;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Misc
+{
+    internal static class NestedAsQueryableHelper
+    {
+        public static void EnsureQueryableMethodHasNestedAsQueryableSource(MethodCallExpression expression, AggregationExpression sourceTranslation)
+        {
+            if (expression.Method.DeclaringType == typeof(Queryable) &&
+                sourceTranslation.Serializer is not INestedAsQueryableSerializer)
+            {
+                throw new ExpressionNotSupportedException(expression, because: "source serializer is not a NestedAsQueryableSerializer");
+            }
+        }
+
+        public static void EnsureQueryableMethodHasNestedAsOrderedQueryableSource(MethodCallExpression expression, AggregationExpression sourceTranslation)
+        {
+            if (expression.Method.DeclaringType == typeof(Queryable) &&
+                sourceTranslation.Serializer is not INestedAsOrderedQueryableSerializer)
+            {
+                throw new ExpressionNotSupportedException(expression, because: "source serializer is not a NestedAsOrderedQueryableSerializer");
+            }
+        }
+    }
+}

src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/EnumerableMethod.cs

@@ -551,6 +551,41 @@ public static bool IsContainsMethod(MethodCallExpression methodCallExpression, o
             return false;
         }
 
+        public static bool IsToArrayMethod(MethodCallExpression methodCallExpression, out Expression sourceExpression)
+        {
+            var method = methodCallExpression.Method;
+            var parameters = method.GetParameters();
+            var arguments = methodCallExpression.Arguments;
+
+            if (method.Name == "ToArray")
+            {
+                var returnType = method.ReturnType;
+                if (returnType.IsArray)
+                {
+                    var returnItemType = returnType.GetElementType();
+
+                    sourceExpression = method switch
+                    {
+                        _ when method.IsStatic && parameters.Length == 1 => arguments[0],
+                        _ when !method.IsStatic && parameters.Length == 0 => methodCallExpression.Object,
+                        _ => null
+                    };
+                    if (sourceExpression != null)
+                    {
+                        var sourceType = sourceExpression.Type;
+                        if (sourceType.ImplementsIEnumerable(out var sourceItemType) &&
+                            sourceItemType == returnItemType)
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            sourceExpression = null;
+            return false;
+        }
+
         public static MethodInfo MakeSelect(Type sourceType, Type resultType)
         {
             return __select.MakeGenericMethod(sourceType, resultType);

src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/QueryableMethod.cs

@@ -24,12 +24,13 @@ namespace MongoDB.Driver.Linq.Linq3Implementation.Reflection
     internal static class QueryableMethod
     {
         // private static fields
-        private static readonly MethodInfo __aggregate;
+        private static readonly MethodInfo __aggregateWithFunc;
         private static readonly MethodInfo __aggregateWithSeedAndFunc;
-        private static readonly MethodInfo __aggregateWithSeedFuncAndSelector;
+        private static readonly MethodInfo __aggregateWithSeedFuncAndResultSelector;
         private static readonly MethodInfo __all;
         private static readonly MethodInfo __any;
         private static readonly MethodInfo __anyWithPredicate;
+        private static readonly MethodInfo __asQueryable;
         private static readonly MethodInfo __averageDecimal;
         private static readonly MethodInfo __averageDecimalWithSelector;
         private static readonly MethodInfo __averageDouble;
@@ -128,12 +129,13 @@ internal static class QueryableMethod
         // static constructor
         static QueryableMethod()
         {
-            __aggregate = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, object, object>> func) => source.Aggregate(func));
+            __aggregateWithFunc = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, object, object>> func) => source.Aggregate(func));
             __aggregateWithSeedAndFunc = ReflectionInfo.Method((IQueryable<object> source, object seed, Expression<Func<object, object, object>> func) => source.Aggregate(seed, func));
-            __aggregateWithSeedFuncAndSelector = ReflectionInfo.Method((IQueryable<object> source, object seed, Expression<Func<object, object, object>> func, Expression<Func<object, object>> selector) => source.Aggregate(seed, func, selector));
+            __aggregateWithSeedFuncAndResultSelector = ReflectionInfo.Method((IQueryable<object> source, object seed, Expression<Func<object, object, object>> func, Expression<Func<object, object>> selector) => source.Aggregate(seed, func, selector));
             __all = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, bool>> predicate) => source.All(predicate));
             __any = ReflectionInfo.Method((IQueryable<object> source) => source.Any());
             __anyWithPredicate = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, bool>> predicate) => source.Any(predicate));
+            __asQueryable = ReflectionInfo.Method((IEnumerable<object> source) => source.AsQueryable());
             __averageDecimal = ReflectionInfo.Method((IQueryable<decimal> source) => source.Average());
             __averageDecimalWithSelector = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, decimal>> selector) => source.Average(selector));
             __averageDouble = ReflectionInfo.Method((IQueryable<double> source) => source.Average());
@@ -149,7 +151,7 @@ static QueryableMethod()
             __averageNullableInt32 = ReflectionInfo.Method((IQueryable<int?> source) => source.Average());
             __averageNullableInt32WithSelector = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, int?>> selector) => source.Average(selector));
             __averageNullableInt64 = ReflectionInfo.Method((IQueryable<long?> source) => source.Average());
-            __averageNullableInt64WithSelector = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, double?>> selector) => source.Average(selector));
+            __averageNullableInt64WithSelector = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, long?>> selector) => source.Average(selector));
             __averageNullableSingle = ReflectionInfo.Method((IQueryable<float?> source) => source.Average());
             __averageNullableSingleWithSelector = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, float?>> selector) => source.Average(selector));
             __averageSingle = ReflectionInfo.Method((IQueryable<float> source) => source.Average());
@@ -231,11 +233,13 @@ static QueryableMethod()
         }
 
         // public properties
-        public static MethodInfo Aggregate => __aggregate;
+        public static MethodInfo AggregateWithFunc => __aggregateWithFunc;
         public static MethodInfo AggregateWithSeedAndFunc => __aggregateWithSeedAndFunc;
-        public static MethodInfo AggregateWithSeedFuncAndSelector => __aggregateWithSeedFuncAndSelector;
+        public static MethodInfo AggregateWithSeedFuncAndResultSelector => __aggregateWithSeedFuncAndResultSelector;
         public static MethodInfo All => __all;
         public static MethodInfo Any => __any;
+        public static MethodInfo AnyWithPredicate => __anyWithPredicate;
+        public static MethodInfo AsQueryable => __asQueryable;
         public static MethodInfo AverageDecimal => __averageDecimal;
         public static MethodInfo AverageDecimalWithSelector => __averageDecimalWithSelector;
         public static MethodInfo AverageDouble => __averageDouble;
@@ -256,7 +260,6 @@ static QueryableMethod()
         public static MethodInfo AverageNullableSingleWithSelector => __averageNullableSingleWithSelector;
         public static MethodInfo AverageSingle => __averageSingle;
         public static MethodInfo AverageSingleWithSelector => __averageSingleWithSelector;
-        public static MethodInfo AnyWithPredicate => __anyWithPredicate;
         public static MethodInfo Cast => __cast;
         public static MethodInfo Concat => __concat;
         public static MethodInfo Contains => __contains;

src/MongoDB.Driver/Linq/Linq3Implementation/Serializers/IEnumerableSerializer.cs

@@ -16,53 +16,19 @@
 using System;
 using System.Collections.Generic;
 using MongoDB.Bson.Serialization;
-using MongoDB.Bson.Serialization.Serializers;
-using MongoDB.Driver.Core.Misc;
 
 namespace MongoDB.Driver.Linq.Linq3Implementation.Serializers
 {
-    internal class IEnumerableSerializer<TItem> : SerializerBase<IEnumerable<TItem>>, IBsonArraySerializer
+    internal class IEnumerableSerializer<TItem> : IEnumerableSerializerBase<IEnumerable<TItem>, TItem>
     {
-        // private fields
-        private readonly IBsonSerializer<TItem> _itemSerializer;
-
         // constructors
         public IEnumerableSerializer(IBsonSerializer<TItem> itemSerializer)
+            : base(itemSerializer)
         {
-            _itemSerializer = Ensure.IsNotNull(itemSerializer, nameof(itemSerializer));
         }
 
-        // public methods
-        public override IEnumerable<TItem> Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
-        {
-            var reader = context.Reader;
-            reader.ReadStartArray();
-            var value = new List<TItem>();
-            while (reader.ReadBsonType() != 0)
-            {
-                var item = _itemSerializer.Deserialize(context);
-                value.Add(item);
-            }
-            reader.ReadEndArray();
-            return value;
-        }
-
-        public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, IEnumerable<TItem> value)
-        {
-            var writer = context.Writer;
-            writer.WriteStartArray();
-            foreach (var item in value)
-            {
-                _itemSerializer.Serialize(context, item);
-            }
-            writer.WriteEndArray();
-        }
-
-        public bool TryGetItemSerializationInfo(out BsonSerializationInfo serializationInfo)
-        {
-            serializationInfo = new BsonSerializationInfo(null, _itemSerializer, typeof(TItem));
-            return true;
-        }
+        // protected methods
+        protected override IEnumerable<TItem> CreateDeserializedValue(List<TItem> items) => items;
     }
 
     internal static class IEnumerableSerializer

src/MongoDB.Driver/Linq/Linq3Implementation/Serializers/IEnumerableSerializerBase.cs

@@ -0,0 +1,69 @@
+/* Copyright 2010-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System.Collections.Generic;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Serializers
+{
+    internal abstract class IEnumerableSerializerBase<TEnumerable, TItem> : SerializerBase<TEnumerable>, IBsonArraySerializer
+        where TEnumerable : IEnumerable<TItem>
+    {
+        // private fields
+        private readonly IBsonSerializer<TItem> _itemSerializer;
+
+        // constructors
+        public IEnumerableSerializerBase(IBsonSerializer<TItem> itemSerializer)
+        {
+            _itemSerializer = Ensure.IsNotNull(itemSerializer, nameof(itemSerializer));
+        }
+
+        // public methods
+        public override TEnumerable Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
+        {
+            var reader = context.Reader;
+            reader.ReadStartArray();
+            var items = new List<TItem>();
+            while (reader.ReadBsonType() != 0)
+            {
+                var item = _itemSerializer.Deserialize(context);
+                items.Add(item);
+            }
+            reader.ReadEndArray();
+            return CreateDeserializedValue(items);
+        }
+
+        public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, TEnumerable value)
+        {
+            var writer = context.Writer;
+            writer.WriteStartArray();
+            foreach (var item in value)
+            {
+                _itemSerializer.Serialize(context, item);
+            }
+            writer.WriteEndArray();
+        }
+
+        public bool TryGetItemSerializationInfo(out BsonSerializationInfo serializationInfo)
+        {
+            serializationInfo = new BsonSerializationInfo(null, _itemSerializer, typeof(TItem));
+            return true;
+        }
+
+        protected abstract TEnumerable CreateDeserializedValue(List<TItem> items);
+    }
+}

src/MongoDB.Driver/Linq/Linq3Implementation/Serializers/IOrderedEnumerableSerializer.cs

@@ -0,0 +1,54 @@
+/* Copyright 2010-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using MongoDB.Bson.Serialization;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Serializers
+{
+    internal class IOrderedEnumerableSerializer<TItem> : IEnumerableSerializerBase<IOrderedEnumerable<TItem>, TItem>
+    {
+        // constructors
+        public IOrderedEnumerableSerializer(IBsonSerializer<TItem> itemSerializer)
+            : base(itemSerializer)
+        {
+        }
+
+        // protected methods
+        protected override IOrderedEnumerable<TItem> CreateDeserializedValue(List<TItem> items) => new IOrderedEnumerableWrapper(items);
+
+        private class IOrderedEnumerableWrapper : IOrderedEnumerable<TItem>
+        {
+            private readonly IEnumerable<TItem> _items;
+            public IOrderedEnumerableWrapper(IEnumerable<TItem> items) => _items = items;
+            public IOrderedEnumerable<TItem> CreateOrderedEnumerable<TKey>(Func<TItem, TKey> keySelector, IComparer<TKey> comparer, bool descending) => throw new InvalidOperationException("ThenBy or ThenByDescending cannot be executed client-side and should be moved to the LINQ query.");
+            public IEnumerator<TItem> GetEnumerator() => _items.GetEnumerator();
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+    }
+
+    internal static class IOrderedEnumerableSerializer
+    {
+        public static IBsonSerializer Create(IBsonSerializer itemSerializer)
+        {
+            var itemType = itemSerializer.ValueType;
+            var serializerType = typeof(IOrderedEnumerableSerializer<>).MakeGenericType(itemType);
+            return (IBsonSerializer)Activator.CreateInstance(serializerType, itemSerializer);
+        }
+    }
+}