CSHARP-1894 (InvalidCastException in FieldValueSerializerHelper on implicit type casting) fix updated to match current upstream master branch.

Author: kreig

src/MongoDB.Driver/FieldValueSerializerHelper.cs

@@ -120,8 +120,10 @@ private static IBsonSerializer GetSerializerForValueType(IBsonSerializer fieldSe
                 }
             }
 
-            // if we can't return a valid value serializer based on the field serializer return null
-            return null;
+            // if we can't return a valid value serializer based on the field serializer return casting serializer
+            var castingSerializerType = typeof(CastingSerializer<,>).MakeGenericType(valueType, fieldType);
+            var castingSerializerConstructor = castingSerializerType.GetTypeInfo().GetConstructor(new[] { fieldSerializerInterfaceType });
+            return (IBsonSerializer)castingSerializerConstructor.Invoke(new object[] { fieldSerializer });
         }
 
         public static IBsonSerializer GetSerializerForValueType(IBsonSerializer fieldSerializer, Type valueType, object value)
@@ -237,5 +239,43 @@ public override void Serialize(BsonSerializationContext context, BsonSerializati
                 }
             }
         }
+
+        //unbound type casting
+        private class CastingSerializer<TFrom, TTo> : SerializerBase<TFrom>
+        {
+            private readonly IBsonSerializer<TTo> _serializer;
+
+            public CastingSerializer(IBsonSerializer<TTo> serializer)
+            {
+                _serializer = serializer;
+            }
+
+            public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, TFrom value)
+            {
+                _serializer.Serialize(context, args, CastValue(value));
+            }
+
+            private TTo CastValue(TFrom value)
+            {
+                if (ReferenceEquals(value, null) || typeof(TTo).GetTypeInfo().IsAssignableFrom(value.GetType()))
+                {
+                    //direct cast with boxing
+                    return (TTo)(object)value;
+                }
+                //cast using TypeDescriptor
+                var converter = TypeDescriptor.GetConverter(value.GetType());
+                if (converter.CanConvertTo(typeof(TTo)))
+                {
+                    return (TTo)converter.ConvertTo(value, typeof(TTo));
+                }
+                converter = TypeDescriptor.GetConverter(typeof(TTo));
+                if (converter.CanConvertFrom(value.GetType()))
+                {
+                    return (TTo)converter.ConvertFrom(value);
+                }
+                //cast with Convert.ChangeType() - last chance
+                return (TTo)Convert.ChangeType(value, typeof(TTo));
+            }
+        }
     }
 }

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

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Linq.Translators;
+using System.ComponentModel;
+using System.Linq.Expressions;
+using MongoDB.Bson;
+using System.Globalization;
+using System.Reflection;
+
+namespace MongoDB.Driver.Tests.Linq.Translators
+{
+    public class PredicateImplicitTypeCastTests : IntegrationTestBase
+    {
+        [Fact]
+        public void Implicit_Type_Casting_Primitive_Types()
+        {
+            Assert(
+                x => x.B == (object)10,
+                0,
+                "{B: '10'}");
+        }
+
+        [Fact]
+        public void Implicit_Type_Casting_With_Custom_TypeConverter()
+        {
+            //register custom type converter for C type
+            TypeDescriptor.AddAttributes(typeof(C), new TypeConverterAttribute(typeof(CExampleTypeCoverter)));
+            //cast string to object so it can be used in predicate
+            var objectToCast = (object)"Dexter";
+            Assert(
+                x => x.C == objectToCast,
+                0,
+                "{C: { '_t' : 'C', D: 'Dexter', E: null, S: null, X: null}}");
+        }
+
+        public void Assert(Expression<Func<Root, bool>> filter, int expectedCount, string expectedFilter)
+        {
+            var serializer = BsonSerializer.SerializerRegistry.GetSerializer<Root>();
+            var filterDocument = PredicateTranslator.Translate(filter, serializer, BsonSerializer.SerializerRegistry);
+
+            var list = __collection.FindSync(filterDocument).ToList();
+
+            filterDocument.Should().Be(BsonDocument.Parse(expectedFilter));
+            list.Count.Should().Be(expectedCount);
+        }
+
+        /// <summary>
+        /// Custom type converter for <see cref="C"/> test class.
+        /// </summary>
+        public class CExampleTypeCoverter : TypeConverter
+        {
+            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+            {
+                if (sourceType == typeof(string)) return true;
+                return base.CanConvertFrom(context, sourceType);
+            }
+
+            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+            {
+                if (value is string) return CreateFromString(value);
+                return base.ConvertFrom(context, culture, value);
+            }
+
+            public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+            {
+                return (typeof(C).GetTypeInfo().IsAssignableFrom(destinationType));
+            }
+
+            public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+            {
+                if (typeof(C).GetTypeInfo().IsAssignableFrom(destinationType))
+                {
+                    if (value is string)
+                    {
+                        return CreateFromString(value);
+                    }
+                }
+                return base.ConvertTo(context, culture, value, destinationType);
+            }
+
+            /// <summary>
+            /// Creates new <see cref="C"/> instance from string.
+            /// </summary>
+            /// <param name="value">String value used for conversion.</param>
+            private C CreateFromString(object value)
+            {
+                return new C { D = (string)value };
+            }
+        }
+    }
+}