CSHARP-4813: Verify more carefully that property named Count is a collection method.

Author: rstam

src/MongoDB.Bson/Serialization/Serializers/DiscriminatedInterfaceSerializer.cs

@@ -19,11 +19,26 @@
 
 namespace MongoDB.Bson.Serialization.Serializers
 {
+    /// <summary>
+    /// An interface implemented by DiscriminatedInterfaceSerializer.
+    /// </summary>
+    public interface IDiscriminatedInterfaceSerializer
+    {
+        /// <summary>
+        /// Gets the interface serializer.
+        /// </summary>
+        IBsonSerializer InterfaceSerializer { get; }
+    }
+
     /// <summary>
     /// Represents a serializer for Interfaces.
     /// </summary>
     /// <typeparam name="TInterface">The type of the interface.</typeparam>
-    public class DiscriminatedInterfaceSerializer<TInterface> : SerializerBase<TInterface>, IBsonDocumentSerializer // where TInterface is an interface
+    public class DiscriminatedInterfaceSerializer<TInterface> :
+        SerializerBase<TInterface>,
+        IBsonDocumentSerializer,
+        IDiscriminatedInterfaceSerializer
+            // where TInterface is an interface
     {
         #region static
         private static IBsonSerializer<TInterface> CreateInterfaceSerializer()
@@ -97,6 +112,14 @@ public DiscriminatedInterfaceSerializer(IDiscriminatorConvention discriminatorCo
             _interfaceSerializer = interfaceSerializer;
         }
 
+        // public properties
+        /// <summary>
+        /// Gets the interface serializer.
+        /// </summary>
+        public IBsonSerializer<TInterface> InterfaceSerializer => _interfaceSerializer;
+
+        IBsonSerializer IDiscriminatedInterfaceSerializer.InterfaceSerializer => _interfaceSerializer;
+
         // public methods
         /// <summary>
         /// Deserializes a value.

src/MongoDB.Bson/Serialization/Serializers/ImpliedImplementationInterfaceSerializer.cs

@@ -14,13 +14,22 @@
 */
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
 using MongoDB.Bson.Serialization.Options;
 
 namespace MongoDB.Bson.Serialization.Serializers
 {
+    /// <summary>
+    /// An interface implemented by ImpliedImplementationInterfaceSerializer.
+    /// </summary>
+    public interface IImpliedImplementationInterfaceSerializer
+    {
+        /// <summary>
+        /// Gets the serializer for the implied implementation.
+        /// </summary>
+        IBsonSerializer ImplementationSerializer { get; }
+    }
+
     /// <summary>
     /// Represents a serializer for Interfaces.
     /// </summary>
@@ -31,7 +40,8 @@ public class ImpliedImplementationInterfaceSerializer<TInterface, TImplementatio
         IBsonArraySerializer,
         IBsonDictionarySerializer,
         IBsonDocumentSerializer,
-        IChildSerializerConfigurable
+        IChildSerializerConfigurable,
+        IImpliedImplementationInterfaceSerializer
             where TImplementation : class, TInterface
     {
         // private fields
@@ -144,6 +154,8 @@ public IBsonSerializer<TImplementation> ImplementationSerializer
             get { return _lazyImplementationSerializer.Value; }
         }
 
+        IBsonSerializer IImpliedImplementationInterfaceSerializer.ImplementationSerializer => ImplementationSerializer;
+
         /// <summary>
         /// Gets the value serializer.
         /// </summary>

src/MongoDB.Bson/Serialization/Serializers/KeyValuePairSerializer.cs

@@ -15,21 +15,29 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
-using MongoDB.Bson.IO;
-using MongoDB.Bson.Serialization.Conventions;
-using MongoDB.Bson.Serialization.Options;
 
 namespace MongoDB.Bson.Serialization.Serializers
 {
+    /// <summary>
+    /// An interface implemented by KeyValuePairSerializer.
+    /// </summary>
+    public interface IKeyValuePairSerializer
+    {
+        /// <summary>
+        /// Gets the representation.
+        /// </summary>
+        BsonType Representation { get;  }
+    }
+
     /// <summary>
     /// Represents a serializer for KeyValuePairs.
     /// </summary>
     /// <typeparam name="TKey">The type of the keys.</typeparam>
     /// <typeparam name="TValue">The type of the values.</typeparam>
     public class KeyValuePairSerializer<TKey, TValue> :
         StructSerializerBase<KeyValuePair<TKey, TValue>>,
-        IBsonDocumentSerializer
+        IBsonDocumentSerializer,
+        IKeyValuePairSerializer
     {
         // private constants
         private static class Flags

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

@@ -14,17 +14,67 @@
 */
 
 using System;
+using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
 
 namespace MongoDB.Driver.Linq.Linq3Implementation.Misc
 {
     internal static class DocumentSerializerHelper
     {
+        public static bool AreMembersRepresentedAsFields(IBsonSerializer serializer, out IBsonDocumentSerializer documentSerializer)
+        {
+            if (serializer is IDiscriminatedInterfaceSerializer discriminatedInterfaceSerializer)
+            {
+                return AreMembersRepresentedAsFields(discriminatedInterfaceSerializer.InterfaceSerializer, out documentSerializer);
+            }
+
+            if (serializer is IDowncastingSerializer downcastingSerializer)
+            {
+                return AreMembersRepresentedAsFields(downcastingSerializer.DerivedSerializer, out documentSerializer);
+            }
+
+            if (serializer is IImpliedImplementationInterfaceSerializer impliedImplementationSerializer)
+            {
+                return AreMembersRepresentedAsFields(impliedImplementationSerializer.ImplementationSerializer, out documentSerializer);
+            }
+
+            if (serializer is IBsonDictionarySerializer)
+            {
+                documentSerializer = null;
+                return false;
+            }
+
+            if (serializer is IKeyValuePairSerializer keyValuePairSerializer)
+            {
+                if (keyValuePairSerializer.Representation == BsonType.Document)
+                {
+                    documentSerializer = (IBsonDocumentSerializer)keyValuePairSerializer;
+                    return true;
+                }
+                else
+                {
+                    documentSerializer = null;
+                    return false;
+                }
+            }
+
+            // for backward compatibility assume that any remaining implementers of IBsonDocumentSerializer represent members as fields
+            if (serializer is IBsonDocumentSerializer tempDocumentSerializer)
+            {
+                documentSerializer = tempDocumentSerializer;
+                return true;
+            }
+
+            documentSerializer = null;
+            return false;
+        }
+
         public static MemberSerializationInfo GetMemberSerializationInfo(IBsonSerializer serializer, string memberName)
         {
-            if (!(serializer is IBsonDocumentSerializer documentSerializer))
+            if (!AreMembersRepresentedAsFields(serializer, out var documentSerializer))
             {
-                throw new NotSupportedException($"Serializer for {serializer.ValueType} must implement IBsonDocumentSerializer to be used with LINQ.");
+                throw new NotSupportedException($"Serializer for {serializer.ValueType} does not represent members as fields.");
             }
 
             if (!(documentSerializer.TryGetMemberSerializationInfo(memberName, out BsonSerializationInfo serializationInfo)))
@@ -41,12 +91,5 @@ public static MemberSerializationInfo GetMemberSerializationInfo(IBsonSerializer
                 return new MemberSerializationInfo(serializationInfo.ElementPath, serializationInfo.Serializer);
             }
         }
-
-        public static bool HasMemberSerializationInfo(IBsonSerializer serializer, string memberName)
-        {
-            return
-                serializer is IBsonDocumentSerializer documentSerializer &&
-                documentSerializer.TryGetMemberSerializationInfo(memberName, out var _);
-        }
     }
 }

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

@@ -13,31 +13,34 @@
 * limitations under the License.
 */
 
-using System;
 using System.Collections;
 using System.Linq.Expressions;
 using MongoDB.Bson;
 using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Options;
+using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver.Linq.Linq3Implementation.Serializers;
 
 namespace MongoDB.Driver.Linq.Linq3Implementation.Misc
 {
     internal static class SerializationHelper
     {
-        public static void EnsureRepresentationIsNumeric(Expression expression, IBsonSerializer serializer)
+        public static void EnsureRepresentationIsArray(Expression expression, IBsonSerializer serializer)
         {
-            if (serializer is IRepresentationConfigurable representationConfigurableSerializer)
+            var representation = GetRepresentation(serializer);
+            if (representation != BsonType.Array)
             {
-                EnsureRepresentationIsNumeric(expression, serializer.ValueType, representationConfigurableSerializer.Representation);
+                throw new ExpressionNotSupportedException(expression, because: "the expression is not represented as an array in the database");
             }
+        }
 
-            static void EnsureRepresentationIsNumeric(Expression expression, Type valueType, BsonType representation)
+        public static void EnsureRepresentationIsNumeric(Expression expression, IBsonSerializer serializer)
+        {
+            var representation = GetRepresentation(serializer);
+            if (!IsNumericRepresentation(representation))
             {
-                if (!IsNumericRepresentation(representation))
-                {
-                    throw new ExpressionNotSupportedException(expression, because: $"serializer for type {valueType} uses a non-numeric representation: {representation}");
-                }
+                throw new ExpressionNotSupportedException(expression, because: $"serializer for type {serializer.ValueType} uses a non-numeric representation: {representation}");
             }
 
             static bool IsNumericRepresentation(BsonType representation)
@@ -50,6 +53,64 @@ static bool IsNumericRepresentation(BsonType representation)
             }
         }
 
+        public static BsonType GetRepresentation(IBsonSerializer serializer)
+        {
+            if (serializer is IDiscriminatedInterfaceSerializer discriminatedInterfaceSerializer)
+            {
+                return GetRepresentation(discriminatedInterfaceSerializer.InterfaceSerializer);
+            }
+
+            if (serializer is IDowncastingSerializer downcastingSerializer)
+            {
+                return GetRepresentation(downcastingSerializer.DerivedSerializer);
+            }
+
+            if (serializer is IImpliedImplementationInterfaceSerializer impliedImplementationSerializer)
+            {
+                return GetRepresentation(impliedImplementationSerializer.ImplementationSerializer);
+            }
+
+            if (serializer is IHasRepresentationSerializer hasRepresentationSerializer)
+            {
+                return hasRepresentationSerializer.Representation;
+            }
+
+            if (serializer is IBsonDictionarySerializer dictionarySerializer)
+            {
+                return dictionarySerializer.DictionaryRepresentation switch
+                {
+                    DictionaryRepresentation.ArrayOfArrays => BsonType.Array,
+                    DictionaryRepresentation.ArrayOfDocuments => BsonType.Array,
+                    DictionaryRepresentation.Document => BsonType.Document,
+                    _ => BsonType.Undefined
+                };
+            }
+
+            if (serializer is IKeyValuePairSerializer keyValuePairSerializer)
+            {
+                return keyValuePairSerializer.Representation;
+            }
+
+            // for backward compatibility assume that any remaining implementers of IBsonDocumentSerializer are represented as documents
+            if (serializer is IBsonDocumentSerializer)
+            {
+                return BsonType.Document;
+            }
+
+            // for backward compatibility assume that any remaining implementers of IBsonArraySerializer are represented as documents
+            if (serializer is IBsonArraySerializer)
+            {
+                return BsonType.Array;
+            }
+
+            return BsonType.Undefined;
+        }
+
+        public static bool IsRepresentedAsDocument(IBsonSerializer serializer)
+        {
+            return SerializationHelper.GetRepresentation(serializer) == BsonType.Document;
+        }
+
         public static BsonValue SerializeValue(IBsonSerializer serializer, ConstantExpression constantExpression, Expression containingExpression)
         {
             var value = constantExpression.Value;

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

@@ -0,0 +1,46 @@
+/* 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.Expressions;
+using System.Reflection;
+using MongoDB.Driver.Linq.Linq3Implementation.Misc;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Reflection
+{
+    internal static class EnumerableProperty
+    {
+        // public methods
+        public static bool IsCountProperty(MemberExpression expression)
+        {
+            // Count is not actually a property defined by IEnumerable but rather defined by several sub-interfaces
+            return
+                expression.Expression != null &&
+                expression.Member is PropertyInfo propertyInfo &&
+                propertyInfo.Name == "Count" &&
+                propertyInfo.PropertyType == typeof(int) &&
+                propertyInfo.GetGetMethod().GetParameters().Length == 0 &&
+                ImplementsCollectionInterface(expression.Expression.Type);
+
+            static bool ImplementsCollectionInterface(Type type)
+                =>
+                    type.Implements(typeof(ICollection)) ||
+                    type.Implements(typeof(ICollection<>)) ||
+                    type.Implements(typeof(IReadOnlyCollection<>));
+        }
+    }
+}

src/MongoDB.Driver/Linq/Linq3Implementation/Serializers/KnownSerializers/KnownSerializerFinder.cs

@@ -112,13 +112,13 @@ protected override Expression VisitMember(MemberExpression node)
             var result = base.VisitMember(node);
 
             var containerSerializer = _registry.GetSerializer(node.Expression);
-            if (containerSerializer is IBsonDocumentSerializer documentSerializer)
+            if (DocumentSerializerHelper.AreMembersRepresentedAsFields(containerSerializer, out var documentSerializer))
             {
                 if (documentSerializer.TryGetMemberSerializationInfo(node.Member.Name, out var memberSerializationInfo))
                 {
                     _currentKnownSerializersNode.AddKnownSerializer(node.Type, memberSerializationInfo.Serializer);
 
-                    if (memberSerializationInfo.Serializer is IBsonDocumentSerializer bsonDocumentSerializer)
+                    if (DocumentSerializerHelper.AreMembersRepresentedAsFields(memberSerializationInfo.Serializer, out var bsonDocumentSerializer))
                     {
                         _currentSerializer = bsonDocumentSerializer;
                     }
@@ -199,7 +199,7 @@ protected override Expression VisitParameter(ParameterExpression node)
             if (_currentSerializer is IBsonArraySerializer arraySerializer &&
                 arraySerializer.TryGetItemSerializationInfo(out var itemSerializationInfo) &&
                 node.Type == itemSerializationInfo.NominalType &&
-                itemSerializationInfo.Serializer is IBsonDocumentSerializer documentSerializer)
+                DocumentSerializerHelper.AreMembersRepresentedAsFields(itemSerializationInfo.Serializer, out var documentSerializer))
             {
                 _currentSerializer = documentSerializer;
                 _currentKnownSerializersNode.AddKnownSerializer(node.Type, documentSerializer);