CSHARP-4499: Support Convert calls to a base type in filter translators.

Author: rstam

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

@@ -0,0 +1,74 @@
+/* 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;
+
+namespace MongoDB.Bson.Serialization.Serializers
+{
+    /// <summary>
+    /// Static factory class for DowncastingSerializer.
+    /// </summary>
+    public static class DowncastingSerializer
+    {
+        /// <summary>
+        /// Creates a new DowncastingSerializer.
+        /// </summary>
+        /// <param name="baseType">The base type.</param>
+        /// <param name="derivedType">The derived type.</param>
+        /// <param name="derivedTypeSerializer">The derived type serializer.</param>
+        /// <returns></returns>
+        public static IBsonSerializer Create(
+            Type baseType,
+            Type derivedType,
+            IBsonSerializer derivedTypeSerializer)
+        {
+            var downcastingSerializerType = typeof(DowncastingSerializer<,>).MakeGenericType(baseType, derivedType);
+            return (IBsonSerializer)Activator.CreateInstance(downcastingSerializerType, derivedTypeSerializer);
+        }
+    }
+
+    /// <summary>
+    /// A serializer for TBase where the actual values are of type TDerived.
+    /// </summary>
+    /// <typeparam name="TBase">The base type.</typeparam>
+    /// <typeparam name="TDerived">The derived type.</typeparam>
+    public class DowncastingSerializer<TBase, TDerived> : SerializerBase<TBase>
+        where TDerived : TBase
+    {
+        private readonly IBsonSerializer<TDerived> _derivedSerializer;
+
+        /// <summary>
+        /// Initializes a new instance of DowncastingSerializer.
+        /// </summary>
+        /// <param name="derivedSerializer">The derived type serializer.</param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public DowncastingSerializer(IBsonSerializer<TDerived> derivedSerializer)
+        {
+            _derivedSerializer = derivedSerializer ?? throw new ArgumentNullException(nameof(derivedSerializer));
+        }
+
+        /// <inheritdoc/>
+        public override TBase Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
+        {
+            return _derivedSerializer.Deserialize(context, args);
+        }
+
+        /// <inheritdoc/>
+        public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, TBase value)
+        {
+            _derivedSerializer.Serialize(context, args, (TDerived)value);
+        }
+    }
+}

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/ToFilterFieldTranslators/ConvertExpressionToFilterFieldTranslator.cs

@@ -49,6 +49,11 @@ public static AstFilterField Translate(TranslationContext context, UnaryExpressi
                     return TranslateConvertToNullable(field);
                 }
 
+                if (IsConvertToBaseType(fieldType, targetType))
+                {
+                    return TranslateConvertToBaseType(field, targetType);
+                }
+
                 if (IsConvertToDerivedType(fieldType, targetType))
                 {
                     return TranslateConvertToDerivedType(field, targetType);
@@ -65,6 +70,11 @@ private static bool IsConvertEnumToUnderlyingType(Type fieldType, Type targetTyp
                 targetType.IsSameAsOrNullableOf(underlyingType);
         }
 
+        private static bool IsConvertToBaseType(Type fieldType, Type targetType)
+        {
+            return fieldType.IsSubclassOf(targetType);
+        }
+
         private static bool IsConvertToDerivedType(Type fieldType, Type targetType)
         {
             return targetType.IsSubclassOf(fieldType);
@@ -135,6 +145,14 @@ private static AstFilterField TranslateConvertEnumToUnderlyingType(AstFilterFiel
             return AstFilter.Field(field.Path, targetSerializer);
         }
 
+        private static AstFilterField TranslateConvertToBaseType(AstFilterField field, Type baseType)
+        {
+            var derivedTypeSerializer = field.Serializer;
+            var derivedType = derivedTypeSerializer.ValueType;
+            var targetSerializer = DowncastingSerializer.Create(baseType, derivedType, derivedTypeSerializer);
+            return AstFilter.Field(field.Path, targetSerializer);
+        }
+
         private static AstFilterField TranslateConvertToDerivedType(AstFilterField field, Type targetType)
         {
             var targetSerializer = BsonSerializer.LookupSerializer(targetType);

tests/MongoDB.Driver.Tests/Linq/Linq3ImplementationTests/Jira/CSharp4499Tests.cs

@@ -0,0 +1,50 @@
+/* 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 MongoDB.Bson;
+using MongoDB.Driver.Linq;
+using MongoDB.TestHelpers.XunitExtensions;
+using Xunit;
+
+namespace MongoDB.Driver.Tests.Linq.Linq3ImplementationTests.Jira
+{
+    public class CSharp4499Tests : Linq3IntegrationTest
+    {
+        [Theory]
+        [ParameterAttributeData]
+        public void ExpressionFieldDefinition_should_work([Values(LinqProvider.V2, LinqProvider.V3)] LinqProvider linqProvider)
+        {
+            var collection = CreateCollection(linqProvider);
+            var fieldDefinition = new ExpressionFieldDefinition<ConcreteClass, object>(x => x.InternalId);
+
+            var queryable = collection.Aggregate()
+                .Sort(Builders<ConcreteClass>.Sort.Ascending(fieldDefinition));
+
+            var stages = Translate(collection, queryable);
+            AssertStages(stages, "{ $sort : { InternalId : 1 } }");
+        }
+
+        private IMongoCollection<ConcreteClass> CreateCollection(LinqProvider linqProvider)
+        {
+            var collection = GetCollection<ConcreteClass>("C", linqProvider);
+            return collection;
+        }
+
+        private class ConcreteClass
+        {
+            public ObjectId InternalId { get; set; }
+        }
+    }
+}