CSHARP-5572: Refactoring ready for review.

Author: rstam

src/MongoDB.Bson/Serialization/IBsonSerializerExtensions.cs

@@ -53,14 +53,19 @@ public static TValue Deserialize<TValue>(this IBsonSerializer<TValue> serializer
         /// <summary>
         /// Gets the serializer for a base type starting from a serializer for a derived type.
         /// </summary>
-        /// <param name="serializer">The serializer for the derived type.</param>
+        /// <param name="derivedTypeSerializer">The serializer for the derived type.</param>
         /// <param name="baseType">The base type.</param>
         /// <returns>The serializer for the base type.</returns>
-        public static IBsonSerializer GetBaseTypeSerializer(this IBsonSerializer serializer, Type baseType)
+        public static IBsonSerializer GetBaseTypeSerializer(this IBsonSerializer derivedTypeSerializer, Type baseType)
         {
-            if (!baseType.IsAssignableFrom(serializer.ValueType))
+            if (derivedTypeSerializer.ValueType == baseType)
             {
-                throw new ArgumentException($"{baseType} is not assignable from {serializer.ValueType}.");
+                return derivedTypeSerializer;
+            }
+
+            if (!baseType.IsAssignableFrom(derivedTypeSerializer.ValueType))
+            {
+                throw new ArgumentException($"{baseType} is not assignable from {derivedTypeSerializer.ValueType}.");
             }
 
             return BsonSerializer.LookupSerializer(baseType); // TODO: should be able to navigate from serializer
@@ -69,14 +74,19 @@ public static IBsonSerializer GetBaseTypeSerializer(this IBsonSerializer seriali
         /// <summary>
         /// Gets the serializer for a derived type starting from a serializer for a base type.
         /// </summary>
-        /// <param name="serializer">The serializer for the base type.</param>
+        /// <param name="baseTypeSerializer">The serializer for the base type.</param>
         /// <param name="derivedType">The derived type.</param>
         /// <returns>The serializer for the derived type.</returns>
-        public static IBsonSerializer GetDerivedTypeSerializer(this IBsonSerializer serializer, Type derivedType)
+        public static IBsonSerializer GetDerivedTypeSerializer(this IBsonSerializer baseTypeSerializer, Type derivedType)
         {
-            if (!serializer.ValueType.IsAssignableFrom(derivedType))
+            if (baseTypeSerializer.ValueType == derivedType)
+            {
+                return baseTypeSerializer;
+            }
+
+            if (!baseTypeSerializer.ValueType.IsAssignableFrom(derivedType))
             {
-                throw new ArgumentException($"{serializer.ValueType} is not assignable from {derivedType}.");
+                throw new ArgumentException($"{baseTypeSerializer.ValueType} is not assignable from {derivedType}.");
             }
 
             return BsonSerializer.LookupSerializer(derivedType); // TODO: should be able to navigate from serializer

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/KnownSerializerFinderHelperMethods.cs

@@ -29,31 +29,26 @@ internal partial class KnownSerializerFinderVisitor
 {
     private void AddKnownSerializer(Expression node, IBsonSerializer serializer) => _knownSerializers.AddSerializer(node, serializer);
 
-    private bool AllAreKnown(IEnumerable<Expression> nodes, out IReadOnlyList<IBsonSerializer> serializers)
+    private bool AllAreKnown(IEnumerable<Expression> nodes, out IReadOnlyList<IBsonSerializer> knownSerializers)
     {
-        var serializersList = new List<IBsonSerializer>();
+        var knownSerializersList = new List<IBsonSerializer>();
         foreach (var node in nodes)
         {
-            if (IsKnown(node, out var knownSerializer))
+            if (IsKnown(node, out var nodeSerializer))
             {
-                serializersList.Add(knownSerializer);
+                knownSerializersList.Add(nodeSerializer);
             }
             else
             {
-                serializers = null;
+                knownSerializers = null;
                 return false;
             }
         }
 
-        serializers = serializersList;
+        knownSerializers = knownSerializersList;
         return true;
     }
 
-    private bool AnyAreNotKnown(IEnumerable<Expression> nodes)
-    {
-        return nodes.Any(IsNotKnown);
-    }
-
     private bool AnyIsKnown(IEnumerable<Expression> nodes, out IBsonSerializer knownSerializer)
     {
         foreach (var node in nodes)
@@ -76,19 +71,17 @@ private bool AnyIsNotKnown(IEnumerable<Expression> nodes)
 
     private bool CanDeduceSerializer(Expression node1, Expression node2, out Expression unknownNode, out IBsonSerializer knownSerializer)
     {
-        if (IsKnown(node1, out var node1Serializer) &&
-            IsNotKnown(node2))
+        if (IsNotKnown(node1) && IsKnown(node2, out var node2Serializer))
         {
-            unknownNode = node2;
-            knownSerializer = node1Serializer;
+            unknownNode = node1;
+            knownSerializer = node2Serializer;
             return true;
         }
 
-        if (IsNotKnown(node1) &&
-            IsKnown(node2, out var node2Serializer))
+        if (IsNotKnown(node2) && IsKnown(node1, out var node1Serializer))
         {
-            unknownNode = node1;
-            knownSerializer = node2Serializer;
+            unknownNode = node2;
+            knownSerializer = node1Serializer;
             return true;
         }
 
@@ -97,74 +90,75 @@ private bool CanDeduceSerializer(Expression node1, Expression node2, out Express
         return false;
     }
 
-    IBsonSerializer CreateCollectionSerializerFromCollectionSerializer(Type type, IBsonSerializer collectionSerializer)
+    IBsonSerializer CreateCollectionSerializerFromCollectionSerializer(Type collectionType, IBsonSerializer collectionSerializer)
     {
-        if (collectionSerializer.ValueType == type)
+        if (collectionSerializer.ValueType == collectionType)
         {
             return collectionSerializer;
         }
 
+        if (collectionSerializer is IUnknowableSerializer)
+        {
+            return UnknowableSerializer.Create(collectionType);
+        }
+
         var itemSerializer = collectionSerializer.GetItemSerializer();
-        return CreateCollectionSerializerFromItemSerializer(type, itemSerializer);
+        return CreateCollectionSerializerFromItemSerializer(collectionType, itemSerializer);
     }
 
-    IBsonSerializer CreateCollectionSerializerFromItemSerializer(Type type, IBsonSerializer itemSerializer)
+    IBsonSerializer CreateCollectionSerializerFromItemSerializer(Type collectionType, IBsonSerializer itemSerializer)
     {
-        return type switch
+        if (itemSerializer is IUnknowableSerializer)
+        {
+            return UnknowableSerializer.Create(collectionType);
+        }
+
+        return collectionType switch
         {
-            _ when type.IsArray => ArraySerializer.Create(itemSerializer),
-            _ when type.IsConstructedGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>) => IEnumerableSerializer.Create(itemSerializer),
-            _ when type.IsConstructedGenericType && type.GetGenericTypeDefinition() == typeof(IOrderedEnumerable<>) => IOrderedEnumerableSerializer.Create(itemSerializer),
-            _ when type.IsConstructedGenericType && type.GetGenericTypeDefinition() == typeof(IQueryable<>) => IQueryableSerializer.Create(itemSerializer),
-            _ => (BsonSerializer.LookupSerializer(type) as IChildSerializerConfigurable)?.WithChildSerializer(itemSerializer)
+            _ when collectionType.IsArray => ArraySerializer.Create(itemSerializer),
+            _ when collectionType.IsConstructedGenericType && collectionType.GetGenericTypeDefinition() == typeof(IEnumerable<>) => IEnumerableSerializer.Create(itemSerializer),
+            _ when collectionType.IsConstructedGenericType && collectionType.GetGenericTypeDefinition() == typeof(IOrderedEnumerable<>) => IOrderedEnumerableSerializer.Create(itemSerializer),
+            _ when collectionType.IsConstructedGenericType && collectionType.GetGenericTypeDefinition() == typeof(IQueryable<>) => IQueryableSerializer.Create(itemSerializer),
+            _ => (BsonSerializer.LookupSerializer(collectionType) as IChildSerializerConfigurable)?.WithChildSerializer(itemSerializer)
         };
     }
 
-    private void DeduceBooleanSerializer(Expression node)
+    private void DeduceBaseTypeAndDerivedTypeSerializers(Expression baseTypeExpression, Expression derivedTypeExpression)
     {
-        if (IsNotKnown(node))
+        if (IsNotKnown(baseTypeExpression) && IsKnown(derivedTypeExpression, out var knownDerivedTypeSerializer))
         {
-            AddKnownSerializer(node, BooleanSerializer.Instance);
+            var baseTypeSerializer = knownDerivedTypeSerializer.GetBaseTypeSerializer(baseTypeExpression.Type);
+            AddKnownSerializer(baseTypeExpression, baseTypeSerializer);
         }
-    }
 
-    private void DeduceBsonDocumentSerializer(Expression node)
-    {
-        if (IsNotKnown(node))
+        if (IsNotKnown(derivedTypeExpression) && IsKnown(baseTypeExpression, out var knownBaseTypeSerializer))
         {
-            AddKnownSerializer(node, BsonDocumentSerializer.Instance);
+            var derivedTypeSerializer = knownBaseTypeSerializer.GetDerivedTypeSerializer(baseTypeExpression.Type);
+            AddKnownSerializer(derivedTypeExpression, derivedTypeSerializer);
         }
     }
 
-    private void DeduceBsonValueSerializer(Expression node)
+    private void DeduceBooleanSerializer(Expression node)
     {
         if (IsNotKnown(node))
         {
-            AddKnownSerializer(node, BsonValueSerializer.Instance);
+            AddKnownSerializer(node, BooleanSerializer.Instance);
         }
     }
 
     private void DeduceCollectionAndCollectionSerializers(Expression collectionExpression1, Expression collectionExpression2)
     {
-        IBsonSerializer collectionSerializer1;
-        IBsonSerializer collectionSerializer2;
-
-        if (IsNotKnown(collectionExpression1) && IsKnown(collectionExpression2, out collectionSerializer2))
+        if (IsNotKnown(collectionExpression1) && IsKnown(collectionExpression2, out var knownCollectionSerializer2))
         {
-            collectionSerializer1 = collectionSerializer2 is IUnknowableSerializer ?
-                UnknowableSerializer.Create(collectionExpression1.Type) :
-                CreateCollectionSerializerFromCollectionSerializer(collectionExpression1.Type, collectionSerializer2);
+            var collectionSerializer1 = CreateCollectionSerializerFromCollectionSerializer(collectionExpression1.Type, knownCollectionSerializer2);
             AddKnownSerializer(collectionExpression1, collectionSerializer1);
         }
 
-        if (IsNotKnown(collectionExpression2) && IsKnown(collectionExpression1, out collectionSerializer1))
+        if (IsNotKnown(collectionExpression2) && IsKnown(collectionExpression1, out var knownCollectionSerializer1))
         {
-            collectionSerializer2 = collectionSerializer1 is IUnknowableSerializer ?
-                UnknowableSerializer.Create(collectionExpression2.Type) :
-                CreateCollectionSerializerFromCollectionSerializer(collectionExpression2.Type, collectionSerializer1);
+            var collectionSerializer2 = CreateCollectionSerializerFromCollectionSerializer(collectionExpression2.Type, knownCollectionSerializer1);
             AddKnownSerializer(collectionExpression2, collectionSerializer2);
         }
-
     }
 
     private void DeduceCollectionAndItemSerializers(Expression collectionExpression, Expression itemExpression)
@@ -181,9 +175,7 @@ private void DeduceItemAndCollectionSerializers(Expression itemExpression, Expre
 
         if (IsNotKnown(collectionExpression) && IsKnown(itemExpression, out itemSerializer))
         {
-            var collectionSerializer = itemSerializer is IUnknowableSerializer ?
-                UnknowableSerializer.Create(collectionExpression.Type) :
-                CreateCollectionSerializerFromItemSerializer(collectionExpression.Type, itemSerializer);
+            var collectionSerializer = CreateCollectionSerializerFromItemSerializer(collectionExpression.Type, itemSerializer);
             if (collectionSerializer != null)
             {
                 AddKnownSerializer(collectionExpression, collectionSerializer);
@@ -201,12 +193,12 @@ private void DeduceSerializer(Expression node, IBsonSerializer serializer)
 
     private void DeduceSerializers(Expression expression1, Expression expression2)
     {
-        if (IsNotKnown(expression1) && IsKnown(expression2, out var expression2Serializer))
+        if (IsNotKnown(expression1) && IsKnown(expression2, out var expression2Serializer) && expression2Serializer.ValueType == expression1.Type)
         {
             AddKnownSerializer(expression1, expression2Serializer);
         }
 
-        if (IsNotKnown(expression2) && IsKnown(expression1, out var expression1Serializer))
+        if (IsNotKnown(expression2) && IsKnown(expression1, out var expression1Serializer)&&  expression1Serializer.ValueType == expression2.Type)
         {
             AddKnownSerializer(expression2, expression1Serializer);
         }
@@ -231,8 +223,8 @@ private void DeduceUnknowableSerializer(Expression node)
 
     private bool IsItemSerializerKnown(Expression node, out IBsonSerializer itemSerializer)
     {
-        if (IsKnown(node, out var serializer) &&
-            serializer is IBsonArraySerializer arraySerializer &&
+        if (IsKnown(node, out var nodeSerializer) &&
+            nodeSerializer is IBsonArraySerializer arraySerializer &&
             arraySerializer.TryGetItemSerializationInfo(out var itemSerializationInfo))
         {
             itemSerializer = itemSerializationInfo.Serializer;

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/KnownSerializerFinderNewExpressionSerializerCreator.cs

@@ -56,7 +56,6 @@ public IBsonSerializer CreateNewExpressionSerializer(
                 {
                     var creatorMapParameter = creatorMapParameters[i];
                     var constructorArgumentExpression = constructorArguments[i];
-                    var constructorArgumentType = constructorArgumentExpression.Type;
                     if (!IsKnown(constructorArgumentExpression, out var constructorArgumentSerializer))
                     {
                         return null;

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/KnownSerializerFinderVisitConditional.cs

@@ -21,17 +21,20 @@ internal partial class KnownSerializerFinderVisitor
 {
     protected override Expression VisitConditional(ConditionalExpression node)
     {
-        var ifTrue = node.IfTrue;
-        var ifFalse = node.IfFalse;
-
-        DeduceSerializers(ifTrue, node);
-        DeduceSerializers(ifFalse, node);
+        var ifTrueExpression = node.IfTrue;
+        var ifFalseExpression = node.IfFalse;
 
+        DeduceConditionaSerializers();
         base.VisitConditional(node);
-
-        DeduceSerializers(ifTrue, ifFalse);
-        DeduceSerializers(node, ifTrue);
+        DeduceConditionaSerializers();
 
         return node;
+
+        void DeduceConditionaSerializers()
+        {
+            DeduceBaseTypeAndDerivedTypeSerializers(node, ifTrueExpression);
+            DeduceBaseTypeAndDerivedTypeSerializers(node, ifFalseExpression);
+            DeduceBaseTypeAndDerivedTypeSerializers(node, ifTrueExpression); // call a second time in case ifFalse is the only known serializer
+        }
     }
 }

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/KnownSerializerFinderVisitConstant.cs

@@ -31,7 +31,6 @@ protected override Expression VisitConstant(ConstantExpression node)
             }
             else
             {
-                // constant => node: registeredSerializer
                 var registeredSerializer = BsonSerializer.LookupSerializer(node.Type); // TODO: don't use static registry
                 AddKnownSerializer(node, registeredSerializer);
             }

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/KnownSerializerFinderVisitIndex.cs

@@ -54,7 +54,6 @@ protected override Expression VisitIndex(IndexExpression node)
                 DeduceSerializer(node, itemSerializer);
             }
         }
-        // TODO: Deduce UnknowableSerializer???
         // handle generic cases?
 
         return node;

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/KnownSerializerFinderVisitLambda.cs

@@ -13,30 +13,21 @@
  * limitations under the License.
  */
 
-using System;
 using System.Linq.Expressions;
+using MongoDB.Driver.Linq.Linq3Implementation.Serializers;
 
 namespace MongoDB.Driver.Linq.Linq3Implementation.KnownSerializerFinders;
 
 internal partial class KnownSerializerFinderVisitor
 {
     protected override Expression VisitLambda<T>(Expression<T> node)
     {
-        base.VisitLambda(node);
+        if (IsNotKnown(node))
+        {
+            var ignoreNodeSerializer = IgnoreNodeSerializer.Create(node.Type);
+            AddKnownSerializer(node, ignoreNodeSerializer);
+        }
 
-        // var parameters = node.Parameters;
-        // var body = node.Body;
-        // if (parameters.Count == 1 &&
-        //     parameters[0] is var parameter &&
-        //     body.Type == parameter.Type &&
-        //     IsKnown(parameter, out var parameterSerializer) &&
-        //     IsNotKnown(body))
-        // {
-        //     // TODO: remove?
-        //     // _knownSerializers.AddSerializer(body, parameterSerializer);
-        //     throw new Exception("Should not reach here.");
-        // }
-
-        return node;
+        return base.VisitLambda(node);
     }
 }

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/KnownSerializerFinderVisitMethodCall.cs

@@ -1244,7 +1244,7 @@ void DeduceAppendOrPrependMethodSerializers()
                 var elementExpression = arguments[1];
 
                 DeduceItemAndCollectionSerializers(elementExpression, sourceExpression);
-                DeduceSerializers(node, sourceExpression);
+                DeduceCollectionAndCollectionSerializers(node, sourceExpression);
             }
             else
             {
@@ -1697,7 +1697,7 @@ void DeduceCreateMethodSerializers()
 #if NET6_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
             if (method.Is(KeyValuePairMethod.Create))
             {
-                if (AnyAreNotKnown(arguments) && IsKnown(node, out var nodeSerializer))
+                if (AnyIsNotKnown(arguments) && IsKnown(node, out var nodeSerializer))
                 {
                     var keyExpression = arguments[0];
                     var valueExpression = arguments[1];
@@ -1721,7 +1721,7 @@ void DeduceCreateMethodSerializers()
  #endif
             if (method.IsOneOf(__tupleOrValueTupleCreateMethods))
             {
-                if (AnyAreNotKnown(arguments) && IsKnown(node, out var nodeSerializer))
+                if (AnyIsNotKnown(arguments) && IsKnown(node, out var nodeSerializer))
                 {
                     if (nodeSerializer is IBsonTupleSerializer tupleSerializer)
                     {

src/MongoDB.Driver/Linq/Linq3Implementation/KnownSerializerFinders/KnownSerializerFinderVisitUnary.cs

@@ -57,8 +57,9 @@ void DeduceUnaryOperatorSerializers()
                 var resultSerializer = unaryOperator switch
                 {
                     ExpressionType.ArrayLength => Int32Serializer.Instance,
-                    ExpressionType.Not => StandardSerializers.GetSerializer(node.Type),
                     ExpressionType.Convert or ExpressionType.TypeAs => GetConvertSerializer(),
+                    ExpressionType.Not => StandardSerializers.GetSerializer(node.Type),
+                    ExpressionType.Quote => IgnoreNodeSerializer.Create(node.Type),
                     _ => null
                 };