Added domain to missing place

Author: papafe

src/MongoDB.Driver/AggregateExpressionDefinition.cs

@@ -174,7 +174,7 @@ public DocumentsAggregateExpressionDefinition(
         public override BsonValue Render(RenderArgs<NoPipelineInput> args)
         {
             var documentSerializer = _documentSerializer ?? args.SerializerRegistry.GetSerializer<TDocument>();
-            return SerializationHelper.SerializeValues(documentSerializer, _documents);
+            return SerializationHelper.SerializeValues(args.SerializationDomain, documentSerializer, _documents);
         }
     }
 }

src/MongoDB.Driver/Core/WireProtocol/Messages/Encoders/BinaryEncoders/CommandMessageBinaryEncoder.cs

@@ -28,8 +28,8 @@ namespace MongoDB.Driver.Core.WireProtocol.Messages.Encoders.BinaryEncoders
     internal sealed class CommandMessageBinaryEncoder : MessageBinaryEncoderBase, IMessageEncoder
     {
         private const int EncryptedMaxBatchSize = 2 * 1024 * 1024; // 2 MiB
+        // Looking at our implementation, it seems that type 0 sections always serialize/deserialize RawBsonDocument/BsonDocument, so they should use the default domain.
         private static readonly ICommandMessageSectionFormatter<Type0CommandMessageSection> __type0SectionFormatter = new Type0SectionFormatter(BsonSerializer.DefaultSerializationDomain);
-        //QUESTION Looking at the spec and our implementation, it seems that type 0 sections always serialize/deserialize RawBsonDocument, so they should use the default domain. Am I missing something?
 
         // constructors
         public CommandMessageBinaryEncoder(Stream stream, MessageEncoderSettings encoderSettings)

src/MongoDB.Driver/Core/WireProtocol/Messages/Encoders/JsonEncoders/CommandMessageJsonEncoder.cs

@@ -33,7 +33,7 @@ internal sealed class CommandMessageJsonEncoder : MessageJsonEncoderBase, IMessa
         public CommandMessageJsonEncoder(TextReader textReader, TextWriter textWriter, MessageEncoderSettings encoderSettings)
             : base(textReader, textWriter, encoderSettings)
         {
-            //QUESTION Looking at the spec and our implementation, it seems that type 0 sections always serialize/deserialize RawBsonDocument, so they should use the default domain. Am I missing something?
+            // Looking at our implementation, it seems that type 0 sections always serialize/deserialize RawBsonDocument/BsonDocument, so they should use the default domain.
             _type0SectionFormatter = new Type0SectionFormatter(BsonSerializer.DefaultSerializationDomain);
             _type1SectionFormatter = new Type1SectionFormatter(SerializationDomain);
         }

src/MongoDB.Driver/Linq/Linq3Implementation/GroupingWithOutputExpressionStageDefinitions.cs

@@ -109,8 +109,8 @@ protected override AstStage RenderGroupingStage(
             var groupByTranslation = ExpressionToAggregationExpressionTranslator.TranslateLambdaBody(context, partiallyEvaluatedGroupBy, inputSerializer, asRoot: true);
 
             var valueSerializer = (IBsonSerializer<TValue>)groupByTranslation.Serializer;
-            var serializedBoundaries = SerializationHelper.SerializeValues(valueSerializer, _boundaries);
-            var serializedDefault = _options != null && _options.DefaultBucket.HasValue ? SerializationHelper.SerializeValue(valueSerializer, _options.DefaultBucket.Value) : null;
+            var serializedBoundaries = SerializationHelper.SerializeValues(context.SerializationDomain, valueSerializer, _boundaries);
+            var serializedDefault = _options != null && _options.DefaultBucket.HasValue ? SerializationHelper.SerializeValue(context.SerializationDomain, valueSerializer, _options.DefaultBucket.Value) : null;
             var pushElements = AstExpression.AccumulatorField("_elements", AstUnaryAccumulatorOperator.Push, AstExpression.RootVar);
             groupingOutputSerializer = IGroupingSerializer.Create(valueSerializer, inputSerializer);
 

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

@@ -195,11 +195,14 @@ public static bool IsRepresentedAsIntegerOrNullableInteger(IBsonSerializer seria
         }
 
         public static BsonValue SerializeValue(IBsonSerializer serializer, ConstantExpression constantExpression, Expression containingExpression)
+            => SerializeValue(BsonSerializer.DefaultSerializationDomain, serializer, constantExpression, containingExpression);
+
+        public static BsonValue SerializeValue(IBsonSerializationDomain serializationDomain, IBsonSerializer serializer, ConstantExpression constantExpression, Expression containingExpression)
         {
             var value = constantExpression.Value;
             if (value == null || serializer.ValueType.IsAssignableFrom(value.GetType()))
             {
-                return SerializeValue(serializer, value);
+                return SerializeValue(serializationDomain, serializer, value);
             }
 
             if (value.GetType().ImplementsIEnumerable(out var itemType) &&
@@ -209,35 +212,40 @@ itemSerializationInfo.Serializer is var itemSerializer &&
                 itemSerializer.ValueType.IsAssignableFrom(itemType))
             {
                 var ienumerableSerializer = IEnumerableSerializer.Create(itemSerializer);
-                return SerializeValue(ienumerableSerializer, value);
+                return SerializeValue(serializationDomain, ienumerableSerializer, value);
             }
 
             throw new ExpressionNotSupportedException(constantExpression, containingExpression, because: "it was not possible to determine how to serialize the constant");
         }
 
+
         public static BsonValue SerializeValue(IBsonSerializer serializer, object value)
+            => SerializeValue(BsonSerializer.DefaultSerializationDomain, serializer, value);
+
+        //FP Isn't this similar to what SerializationInfo does...?
+        public static BsonValue SerializeValue(IBsonSerializationDomain serializationDomain, IBsonSerializer serializer, object value)
         {
             var document = new BsonDocument();
             using (var writer = new BsonDocumentWriter(document))
             {
                 writer.WriteStartDocument();
                 writer.WriteName("_v");
-                var context = BsonSerializationContext.CreateRoot(writer, BsonSerializer.DefaultSerializationDomain); //QUESTION Is it ok here to use the default domain?
+                var context = BsonSerializationContext.CreateRoot(writer, serializationDomain);
                 serializer.Serialize(context, value);
                 writer.WriteEndDocument();
             }
             return document["_v"];
         }
 
-        public static BsonArray SerializeValues(IBsonSerializer itemSerializer, IEnumerable values)
+        public static BsonArray SerializeValues(IBsonSerializationDomain serializationDomain, IBsonSerializer itemSerializer, IEnumerable values)
         {
             var document = new BsonDocument();
             using (var writer = new BsonDocumentWriter(document))
             {
                 writer.WriteStartDocument();
                 writer.WriteName("_v");
                 writer.WriteStartArray();
-                var context = BsonSerializationContext.CreateRoot(writer, BsonSerializer.DefaultSerializationDomain); //QUESTION Is it ok here to use the default domain?
+                var context = BsonSerializationContext.CreateRoot(writer, serializationDomain);
                 foreach(var value in values)
                 {
                     itemSerializer.Serialize(context, value);

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/AppendOrPrependMethodToAggregationExpressionTranslator.cs

@@ -56,7 +56,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
                 if (elementExpression is ConstantExpression elementConstantExpression)
                 {
                     var value = elementConstantExpression.Value;
-                    var serializedValue = SerializationHelper.SerializeValue(itemSerializer, value);
+                    var serializedValue = SerializationHelper.SerializeValue(context.SerializationDomain, itemSerializer, value);
                     elementTranslation = new TranslatedExpression(elementExpression, AstExpression.Constant(serializedValue), itemSerializer);
                 }
                 else

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/ConstantMethodToAggregationExpressionTranslator.cs

@@ -58,7 +58,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
 
                 if (serializer != null)
                 {
-                    var serializedValue = SerializationHelper.SerializeValue(serializer, value);
+                    var serializedValue = SerializationHelper.SerializeValue(context.SerializationDomain, serializer, value);
                     var ast = AstExpression.Constant(serializedValue);
                     return new TranslatedExpression(expression, ast, serializer);
                 }

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/ContainsKeyMethodToAggregationExpressionTranslator.cs

@@ -64,7 +64,7 @@ private static AstExpression GetKeyFieldName(TranslationContext context, Express
             if (keyExpression is ConstantExpression keyConstantExpression)
             {
                 var keyValue = keyConstantExpression.Value;
-                var serializedKeyValue = SerializationHelper.SerializeValue(keySerializer, keyValue);
+                var serializedKeyValue = SerializationHelper.SerializeValue(context.SerializationDomain, keySerializer, keyValue);
                 ThrowIfKeyIsNotRepresentedAsAString(expression, serializedKeyValue.BsonType);
                 return AstExpression.Constant(serializedKeyValue);
             }

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/ConvertMethodToAggregationExpressionTranslator.cs

@@ -59,14 +59,15 @@ private static (BsonBinarySubType? subType, ByteOrder? byteOrder, string format,
         {
             return optionsExpression switch
             {
-                ConstantExpression constantExpression => TranslateOptions(constantExpression, toSerializer),
+                ConstantExpression constantExpression => TranslateOptions(context.SerializationDomain, constantExpression, toSerializer),
                 MemberInitExpression memberInitExpressionExpression => TranslateOptions(context, expression, memberInitExpressionExpression, toSerializer),
                 _ => throw new ExpressionNotSupportedException(optionsExpression, containingExpression: expression, because: "the options argument must be either a constant or a member initialization expression.")
             };
         }
 
         private static (BsonBinarySubType? subType, ByteOrder? byteOrder, string format, AstExpression onErrorAst, AstExpression onNullAst)
             TranslateOptions(
+                IBsonSerializationDomain serializationDomain,
                 ConstantExpression optionsExpression,
                 IBsonSerializer toSerializer)
         {
@@ -78,13 +79,13 @@ private static (BsonBinarySubType? subType, ByteOrder? byteOrder, string format,
             {
                 if (options.OnErrorWasSet(out var onErrorValue))
                 {
-                    var serializedOnErrorValue = SerializationHelper.SerializeValue(toSerializer, onErrorValue);
+                    var serializedOnErrorValue = SerializationHelper.SerializeValue(serializationDomain, toSerializer, onErrorValue);
                     onErrorAst = AstExpression.Constant(serializedOnErrorValue);
                 }
 
                 if (options.OnNullWasSet(out var onNullValue))
                 {
-                    var serializedOnNullValue = SerializationHelper.SerializeValue(toSerializer, onNullValue);
+                    var serializedOnNullValue = SerializationHelper.SerializeValue(serializationDomain, toSerializer, onNullValue);
                     onNullAst = AstExpression.Constant(serializedOnNullValue);
                 }
             }

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/DefaultIfEmptyMethodToAggregationExpressionTranslator.cs

@@ -64,7 +64,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
                 {
                     var sourceItemSerializer = ArraySerializerHelper.GetItemSerializer(sourceTranslation.Serializer);
                     var defaultValue = sourceItemSerializer.ValueType.GetDefaultValue();
-                    var serializedDefaultValue = SerializationHelper.SerializeValue(sourceItemSerializer, defaultValue);
+                    var serializedDefaultValue = SerializationHelper.SerializeValue(context.SerializationDomain, sourceItemSerializer, defaultValue);
                     defaultValueAst = AstExpression.Constant(new BsonArray { serializedDefaultValue });
                 }
                 var ast = AstExpression.Let(