CSHARP-4567: Support implicit conversion when lambda body returns a type assignable to the lambda return type.

Author: rstam

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

@@ -65,7 +65,7 @@ public static IBsonSerializer Create(
     /// </summary>
     /// <typeparam name="TBase">The base type.</typeparam>
     /// <typeparam name="TDerived">The derived type.</typeparam>
-    public class DowncastingSerializer<TBase, TDerived> : SerializerBase<TBase>, IBsonDocumentSerializer, IDowncastingSerializer
+    public class DowncastingSerializer<TBase, TDerived> : SerializerBase<TBase>, IBsonArraySerializer, IBsonDocumentSerializer, IDowncastingSerializer
         where TDerived : TBase
     {
         private readonly IBsonSerializer<TDerived> _derivedSerializer;
@@ -94,13 +94,24 @@ public DowncastingSerializer(IBsonSerializer<TDerived> derivedSerializer)
         /// <inheritdoc/>
         public override TBase Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
         {
-            return _derivedSerializer.Deserialize(context, args);
+            return _derivedSerializer.Deserialize(context);
         }
 
         /// <inheritdoc/>
         public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, TBase value)
         {
-            _derivedSerializer.Serialize(context, args, (TDerived)value);
+            _derivedSerializer.Serialize(context, (TDerived)value);
+        }
+
+        /// <inheritdoc/>
+        public bool TryGetItemSerializationInfo(out BsonSerializationInfo serializationInfo)
+        {
+            if (_derivedSerializer is IBsonArraySerializer arraySerializer)
+            {
+                return arraySerializer.TryGetItemSerializationInfo(out serializationInfo);
+            }
+
+            throw new InvalidOperationException($"The class {_derivedSerializer.GetType().FullName} does not implement IBsonArraySerializer.");
         }
 
         /// <inheritdoc/>

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/ExpressionToAggregationExpressionTranslator.cs

@@ -17,6 +17,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver.Linq.Linq3Implementation.Ast.Expressions;
 using MongoDB.Driver.Linq.Linq3Implementation.Misc;
 using MongoDB.Driver.Linq.Linq3Implementation.Serializers;
@@ -115,7 +116,25 @@ public static AggregationExpression TranslateLambdaBody(
                     context.CreateSymbolWithVarName(parameterExpression, varName: "ROOT", parameterSerializer, isCurrent: true) :
                     context.CreateSymbol(parameterExpression, parameterSerializer, isCurrent: false);
             var lambdaContext = context.WithSymbol(parameterSymbol);
-            return Translate(lambdaContext, lambdaExpression.Body);
+            var translatedBody = Translate(lambdaContext, lambdaExpression.Body);
+
+            var lambdaReturnType = lambdaExpression.ReturnType;
+            var bodySerializer = translatedBody.Serializer;
+            var bodyType = bodySerializer.ValueType;
+            if (bodyType != lambdaReturnType)            
+            {
+                if (lambdaReturnType.IsAssignableFrom(bodyType))
+                {
+                    var downcastingSerializer = DowncastingSerializer.Create(baseType: lambdaReturnType, derivedType: bodyType, derivedTypeSerializer: bodySerializer);
+                    translatedBody = new AggregationExpression(translatedBody.Expression, translatedBody.Ast, downcastingSerializer);
+                }
+                else
+                {
+                    throw new ExpressionNotSupportedException(lambdaExpression, because: "lambda body type is not convertible to lambda return type");
+                }
+            }
+
+            return translatedBody;
         }
     }
 }

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

@@ -0,0 +1,73 @@
+/* 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.Linq.Expressions;
+using FluentAssertions;
+using MongoDB.Driver.Core.Misc;
+using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
+using MongoDB.Driver.Linq;
+using MongoDB.TestHelpers.XunitExtensions;
+using Xunit;
+
+namespace MongoDB.Driver.Tests.Linq.Linq3ImplementationTests.Jira
+{
+    public class CSharp4567Tests : Linq3IntegrationTest
+    {
+        [Theory]
+        [ParameterAttributeData]
+        public void Projection_to_derived_type_should_work(
+            [Values(LinqProvider.V2, LinqProvider.V3)] LinqProvider linqProvider)
+        {
+            RequireServer.Check().Supports(Feature.FindProjectionExpressions);
+            var collection = GetCollection(linqProvider);
+            Expression<Func<C, object>> projection = x => new R { X = x.Id };
+
+            var find = collection.Find("{}").Project(projection);
+
+            var translatedProjection = TranslateFindProjection(collection, find);
+            if (linqProvider == LinqProvider.V2)
+            {
+                translatedProjection.Should().Be("{ _id : 1 }");
+            }
+            else
+            {
+                translatedProjection.Should().Be("{ X : '$_id', _id : 0 }");
+            }
+
+            var result = (R)find.Single();
+            result.X.Should().Be(1);
+        }
+
+        private IMongoCollection<C> GetCollection(LinqProvider linqProvider)
+        {
+            var collection = GetCollection<C>("test", linqProvider);
+            CreateCollection(
+                collection,
+                new C { Id = 1 });
+            return collection;
+        }
+
+        private class C
+        {
+            public int Id { get; set; }
+        }
+
+        private class R
+        {
+            public int X { get; set; }
+        }
+    }
+}