Various fixes

papafe · papafe · commit 7f5ed7a2559b · 2025-06-20T14:17:38.000+02:00
diff --git a/src/MongoDB.Bson/Serialization/BsonClassMap.cs b/src/MongoDB.Bson/Serialization/BsonClassMap.cs
@@ -122,7 +122,7 @@ public IEnumerable<BsonCreatorMap> CreatorMaps
         /// </summary>
         public IConventionPack ConventionPack
         {
-            get { return BsonSerializer.DefaultSerializationDomain.ConventionRegistry.Lookup(_classType); }  //TODO This is not completely correct, this should be eliminated.
+            get { return BsonSerializer.DefaultSerializationDomain.ConventionRegistry.Lookup(_classType); }
         }
 
         /// <summary>
diff --git a/src/MongoDB.Bson/Serialization/BsonMemberMap.cs b/src/MongoDB.Bson/Serialization/BsonMemberMap.cs
@@ -56,7 +56,7 @@ public BsonMemberMap(BsonClassMap classMap, MemberInfo memberInfo)
         {
             _classMap = classMap;
             _memberInfo = memberInfo;
-            _memberType = BsonClassMap.GetMemberInfoType(memberInfo);
+            _memberType = BsonClassMap.GetMemberInfoType(memberInfo); //FP This is more of a utility method, it can stay like this
             _memberTypeIsBsonValue = typeof(BsonValue).GetTypeInfo().IsAssignableFrom(_memberType);
 
             Reset();
diff --git a/src/MongoDB.Driver/Core/Operations/RetryableInsertCommandOperation.cs b/src/MongoDB.Driver/Core/Operations/RetryableInsertCommandOperation.cs
@@ -139,7 +139,7 @@ public override void Serialize(BsonSerializationContext context, BsonSerializati
                 {
                     if (_cachedSerializer.ValueType != actualType)
                     {
-                        _cachedSerializer = BsonSerializer.LookupSerializer(actualType);
+                        _cachedSerializer = BsonSerializer.LookupSerializer(actualType);  //FP This needs to go, need to access MongoDB.Bson internals to access domain
                     }
                     serializer = _cachedSerializer;
                 }
diff --git a/src/MongoDB.Driver/Core/WireProtocol/Messages/Encoders/BinaryEncoders/ClientBulkWriteOpsSectionFormatter.cs b/src/MongoDB.Driver/Core/WireProtocol/Messages/Encoders/BinaryEncoders/ClientBulkWriteOpsSectionFormatter.cs
@@ -63,7 +63,7 @@ public void FormatSection(ClientBulkWriteOpsCommandMessageSection section, IBson
                 throw new ArgumentException("Writer must be an instance of BsonBinaryWriter.");
             }
 
-            _serializerRegistry = BsonSerializer.SerializerRegistry; //FP This needs to go
+            _serializerRegistry = BsonSerializer.SerializerRegistry; //FP This needs to go, need to access MongoDB.Bson internals to access domain
             var serializationContext = BsonSerializationContext.CreateRoot(binaryWriter);
             _idsMap = section.IdsMap;
             var stream = binaryWriter.BsonStream;
diff --git a/src/MongoDB.Driver/FieldValueSerializerHelper.cs b/src/MongoDB.Driver/FieldValueSerializerHelper.cs
@@ -51,7 +51,7 @@ public static IBsonSerializer GetSerializerForValueType(IBsonSerializer fieldSer
             // serialize numeric values without converting them
             if (fieldType.IsNumeric() && valueType.IsNumeric())
             {
-                var valueSerializer = BsonSerializer.SerializerRegistry.GetSerializer(valueType);
+                var valueSerializer = BsonSerializer.SerializerRegistry.GetSerializer(valueType);  //QUESTION What to we do here? We don't even use the input serializer registry. Probably ask Robert
                 if (HasStringRepresentation(fieldSerializer))
                 {
                     valueSerializer = WithStringRepresentation(valueSerializer);
diff --git a/src/MongoDB.Driver/GeoJsonObjectModel/Serializers/GeoJsonPolygonSerializer.cs b/src/MongoDB.Driver/GeoJsonObjectModel/Serializers/GeoJsonPolygonSerializer.cs
@@ -32,6 +32,7 @@ private static class Flags
 
         // private fields
         private readonly IBsonSerializer<GeoJsonPolygonCoordinates<TCoordinates>> _coordinatesSerializer = BsonSerializer.LookupSerializer<GeoJsonPolygonCoordinates<TCoordinates>>();
+        //QUESTION This happens in all GeoJsonOBjectModel serializers, what do we do here? Do we just lookup the serialzer in each Serialize/Deserialize or do we cache it?
         private readonly GeoJsonObjectSerializerHelper<TCoordinates> _helper;
 
         // constructors
diff --git a/src/MongoDB.Driver/GridFS/GridFSBucketOptions.cs b/src/MongoDB.Driver/GridFS/GridFSBucketOptions.cs
@@ -243,7 +243,7 @@ public ReadPreference ReadPreference
         /// </value>
         public IBsonSerializerRegistry SerializerRegistry
         {
-            get { return BsonSerializer.SerializerRegistry; }  //TODO This is wrong
+            get { return BsonSerializer.SerializerRegistry; }  //QUESTION What do we do in this case...? Given it's read only, we could ignore it? Also, why the immutable options have a serializer registry and the non-immutable options do not?
         }
 
         /// <summary>
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/ArrayLengthExpressionToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/ArrayLengthExpressionToAggregationExpressionTranslator.cs
@@ -28,7 +28,7 @@ public static TranslatedExpression Translate(TranslationContext context, UnaryEx
                 var arrayExpression = expression.Operand;
                 var arrayTranslation = ExpressionToAggregationExpressionTranslator.TranslateEnumerable(context, arrayExpression);
                 var ast = AstExpression.Size(arrayTranslation.Ast);
-                var serializer = BsonSerializer.LookupSerializer(expression.Type);
+                var serializer = context.SerializationDomain.LookupSerializer(expression.Type);
                 return new TranslatedExpression(expression, ast, serializer);
             }
 
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/ConvertExpressionToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/ConvertExpressionToAggregationExpressionTranslator.cs
@@ -44,13 +44,13 @@ sourceExpression is UnaryExpression unarySourceExpression &&
                 }
 
                 var sourceTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, sourceExpression);
-                return Translate(expression, sourceType, targetType, sourceTranslation);
+                return Translate(expression, sourceType, targetType, sourceTranslation, context.SerializationDomain);
             }
 
             throw new ExpressionNotSupportedException(expression);
         }
 
-        private static TranslatedExpression Translate(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation)
+        private static TranslatedExpression Translate(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation, IBsonSerializationDomain serializationDomain)
         {
             if (targetType == sourceType)
             {
@@ -60,12 +60,12 @@ private static TranslatedExpression Translate(UnaryExpression expression, Type s
             // from Nullable<T> must be handled before to Nullable<T>
             if (IsConvertFromNullableType(sourceType))
             {
-                return TranslateConvertFromNullableType(expression, sourceType, targetType, sourceTranslation);
+                return TranslateConvertFromNullableType(expression, sourceType, targetType, sourceTranslation, serializationDomain);
             }
 
             if (IsConvertToNullableType(targetType))
             {
-                return TranslateConvertToNullableType(expression, sourceType, targetType, sourceTranslation);
+                return TranslateConvertToNullableType(expression, sourceType, targetType, sourceTranslation, serializationDomain);
             }
 
             // from here on we know there are no longer any Nullable<T> types involved
@@ -97,7 +97,7 @@ private static TranslatedExpression Translate(UnaryExpression expression, Type s
 
             if (IsConvertToDerivedType(sourceType, targetType))
             {
-                return TranslateConvertToDerivedType(expression, targetType, sourceTranslation);
+                return TranslateConvertToDerivedType(expression, targetType, sourceTranslation, serializationDomain);
             }
 
             var ast = sourceTranslation.Ast;
@@ -177,10 +177,9 @@ private static TranslatedExpression TranslateConvertToBaseType(UnaryExpression e
             return new TranslatedExpression(expression, sourceTranslation.Ast, downcastingSerializer);
         }
 
-        private static TranslatedExpression TranslateConvertToDerivedType(UnaryExpression expression, Type targetType, TranslatedExpression sourceTranslation)
+        private static TranslatedExpression TranslateConvertToDerivedType(UnaryExpression expression, Type targetType, TranslatedExpression sourceTranslation, IBsonSerializationDomain serializationDomain)
         {
-            var serializer = BsonSerializer.LookupSerializer(targetType);
-
+            var serializer = serializationDomain.LookupSerializer(targetType);
             return new TranslatedExpression(expression, sourceTranslation.Ast, serializer);
         }
 
@@ -218,15 +217,15 @@ private static TranslatedExpression TranslateConvertEnumToUnderlyingType(UnaryEx
             return new TranslatedExpression(expression, sourceTranslation.Ast, targetSerializer);
         }
 
-        private static TranslatedExpression TranslateConvertFromNullableType(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation)
+        private static TranslatedExpression TranslateConvertFromNullableType(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation, IBsonSerializationDomain serializationDomain)
         {
             if (sourceType.IsNullable(out var sourceValueType))
             {
                 var (sourceVarBinding, sourceAst) = AstExpression.UseVarIfNotSimple("source", sourceTranslation.Ast);
                 var sourceNullableSerializer = (INullableSerializer)sourceTranslation.Serializer;
                 var sourceValueSerializer = sourceNullableSerializer.ValueSerializer;
                 var sourceValueTranslation = new TranslatedExpression(expression.Operand, sourceAst, sourceValueSerializer);
-                var convertTranslation = Translate(expression, sourceValueType, targetType, sourceValueTranslation);
+                var convertTranslation = Translate(expression, sourceValueType, targetType, sourceValueTranslation, serializationDomain);
 
                 // note: we would have liked to throw a query execution error here if the value is null and the target type is not nullable but there is no way to do that in MQL
                 // so we just return null instead and the user must check for null themselves if they want to define what happens when the value is null
@@ -242,7 +241,7 @@ private static TranslatedExpression TranslateConvertFromNullableType(UnaryExpres
             throw new ExpressionNotSupportedException(expression, because: "sourceType is not nullable");
         }
 
-        private static TranslatedExpression TranslateConvertToNullableType(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation)
+        private static TranslatedExpression TranslateConvertToNullableType(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation, IBsonSerializationDomain serializationDomain)
         {
             if (sourceType.IsNullable())
             {
@@ -252,7 +251,7 @@ private static TranslatedExpression TranslateConvertToNullableType(UnaryExpressi
 
             if (targetType.IsNullable(out var targetValueType))
             {
-                var convertTranslation = Translate(expression, sourceType, targetValueType, sourceTranslation);
+                var convertTranslation = Translate(expression, sourceType, targetValueType, sourceTranslation, serializationDomain);
                 var nullableSerializer = NullableSerializer.Create(convertTranslation.Serializer);
                 return new TranslatedExpression(expression, convertTranslation.Ast, nullableSerializer);
             }
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/OfTypeMethodToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/OfTypeMethodToAggregationExpressionTranslator.cs
@@ -56,7 +56,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
                 var nominalType = itemSerializer.ValueType;
                 var nominalTypeSerializer = itemSerializer;
                 var actualType = method.GetGenericArguments().Single();
-                var actualTypeSerializer = BsonSerializer.LookupSerializer(actualType);
+                var actualTypeSerializer = context.SerializationDomain.LookupSerializer(actualType);
 
                 AstExpression ast;
                 if (nominalType == actualType)
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/StandardDeviationMethodsToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/StandardDeviationMethodsToAggregationExpressionTranslator.cs
@@ -48,12 +48,12 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
                             input: sourceTranslation.Ast,
                             @as: selectorParameterSymbol.Var,
                             @in: selectorTranslation.Ast);
-                        var selectorResultSerializer = BsonSerializer.LookupSerializer(selectorLambda.ReturnType);
+                        var selectorResultSerializer = context.SerializationDomain.LookupSerializer(selectorLambda.ReturnType);
                         sourceTranslation = new TranslatedExpression(selectorLambda, selectorAst, selectorResultSerializer);
                     }
 
                     var ast = AstExpression.StdDev(stddevOperator, sourceTranslation.Ast);
-                    var serializer = BsonSerializer.LookupSerializer(expression.Type);
+                    var serializer = context.SerializationDomain.LookupSerializer(expression.Type);
                     return new TranslatedExpression(expression, ast, serializer);
                 }
             }
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/WindowMethodToAggregationExpressionTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/WindowMethodToAggregationExpressionTranslator.cs
@@ -281,7 +281,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
                 {
                     var @operator = GetNullaryWindowOperator(method);
                     var ast = AstExpression.NullaryWindowExpression(@operator, window);
-                    var serializer = BsonSerializer.LookupSerializer(method.ReturnType); // TODO: use correct serializer
+                    var serializer = context.SerializationDomain.LookupSerializer(method.ReturnType); // TODO: use correct serializer
                     return new TranslatedExpression(expression, ast, serializer);
                 }
 
@@ -296,7 +296,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
                     ThrowIfSelectorTranslationIsNull(selectorTranslation);
                     var @operator = GetUnaryWindowOperator(method);
                     var ast = AstExpression.UnaryWindowExpression(@operator, selectorTranslation.Ast, window);
-                    var serializer = BsonSerializer.LookupSerializer(method.ReturnType); // TODO: use correct serializer
+                    var serializer = context.SerializationDomain.LookupSerializer(method.ReturnType); // TODO: use correct serializer
                     return new TranslatedExpression(expression, ast, serializer);
                 }
 
@@ -309,7 +309,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
 
                     var @operator = GetBinaryWindowOperator(method);
                     var ast = AstExpression.BinaryWindowExpression(@operator, selector1Translation.Ast, selector2Translation.Ast, window);
-                    var serializer = BsonSerializer.LookupSerializer(method.ReturnType); // TODO: use correct serializer
+                    var serializer = context.SerializationDomain.LookupSerializer(method.ReturnType); // TODO: use correct serializer
                     return new TranslatedExpression(expression, ast, serializer);
                 }
 
@@ -324,7 +324,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
 
                     var @operator = GetDerivativeOrIntegralWindowOperator(method);
                     var ast = AstExpression.DerivativeOrIntegralWindowExpression(@operator, selectorTranslation.Ast, unit, window);
-                    var serializer = BsonSerializer.LookupSerializer(method.ReturnType); // TODO: use correct serializer
+                    var serializer = context.SerializationDomain.LookupSerializer(method.ReturnType); // TODO: use correct serializer
                     return new TranslatedExpression(expression, ast, serializer);
                 }
 
@@ -335,7 +335,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
                     var weighting = weightingExpression.GetConstantValue<ExponentialMovingAverageWeighting>(expression);
 
                     var ast = AstExpression.ExponentialMovingAverageWindowExpression(selectorTranslation.Ast, weighting, window);
-                    var serializer = BsonSerializer.LookupSerializer(method.ReturnType); // TODO: use correct serializer
+                    var serializer = context.SerializationDomain.LookupSerializer(method.ReturnType); // TODO: use correct serializer
                     return new TranslatedExpression(expression, ast, serializer);
                 }
 
@@ -354,7 +354,7 @@ public static TranslatedExpression Translate(TranslationContext context, MethodC
                     }
 
                     var ast = AstExpression.ShiftWindowExpression(selectorTranslation.Ast, by, defaultValue);
-                    var serializer = BsonSerializer.LookupSerializer(method.ReturnType); // TODO: use correct serializer
+                    var serializer = context.SerializationDomain.LookupSerializer(method.ReturnType); // TODO: use correct serializer
                     return new TranslatedExpression(expression, ast, serializer);
                 }
             }
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/MethodTranslators/InjectMethodToFilterTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToFilterTranslators/MethodTranslators/InjectMethodToFilterTranslator.cs
@@ -58,7 +58,6 @@ public static AstFilter Translate(TranslationContext context, MethodCallExpressi
                 {
                     throw new ExpressionNotSupportedException(expression, because: $"FilterDefinition TDocument type: {filterDefinitionDocumentType} does not match document type {documentSerializer.ValueType} ");
                 }
-                var serializerRegistry = BsonSerializer.SerializerRegistry;
 
                 var renderFilterMethod = __renderFilterMethodInfo.MakeGenericMethod(filterDefinitionDocumentType);
                 var renderedFilter = (BsonDocument)renderFilterMethod.Invoke(null, new[] { filterDefinition, documentSerializer, context.SerializationDomain, context.TranslationOptions });
diff --git a/src/MongoDB.Driver/MongoDatabase.cs b/src/MongoDB.Driver/MongoDatabase.cs
@@ -660,7 +660,7 @@ private Task CreateCollectionHelperAsync<TDocument>(IClientSessionHandle session
 
         private IWriteOperation<BsonDocument> CreateCreateCollectionOperation<TDocument>(string name, CreateCollectionOptions<TDocument> options, ExpressionTranslationOptions translationOptions)
         {
-            var serializerRegistry = options.SerializerRegistry ?? BsonSerializer.SerializerRegistry;  //TODO What do we do here....?
+            var serializerRegistry = options.SerializerRegistry ?? BsonSerializer.SerializerRegistry;  //QUESTION What do we do here....?
             var documentSerializer = options.DocumentSerializer ?? serializerRegistry.GetSerializer<TDocument>();
 
             var clusteredIndex = options.ClusteredIndex?.Render(documentSerializer, serializerRegistry, translationOptions);
diff --git a/src/MongoDB.Driver/OfTypeSerializer.cs b/src/MongoDB.Driver/OfTypeSerializer.cs
@@ -47,23 +47,19 @@ obj is OfTypeSerializer<TRootDocument, TDerivedDocument> other &&
 
         public bool
             GetDocumentId(object document, out object id, out Type idNominalType, out IIdGenerator idGenerator)
-                => GetDocumentId(document, BsonSerializer.DefaultSerializationDomain, out id, out idNominalType, out idGenerator);
-
-        public bool GetDocumentId(object document, IBsonSerializationDomain serializationDomain, out object id, out Type idNominalType,
-            out IIdGenerator idGenerator)
-        {
-            if (_derivedDocumentSerializer is IBsonIdProvider idProvider)
             {
-                return idProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator);
+                if (_derivedDocumentSerializer is IBsonIdProvider idProvider)
+                {
+                    return idProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator);
+                }
+                else
+                {
+                    id = null;
+                    idNominalType = null;
+                    idGenerator = null;
+                    return false;
+                }
             }
-            else
-            {
-                id = null;
-                idNominalType = null;
-                idGenerator = null;
-                return false;
-            }
-        }
 
         public override int GetHashCode() => 0;
 
diff --git a/src/MongoDB.Driver/PipelineStageDefinitionBuilder.cs b/src/MongoDB.Driver/PipelineStageDefinitionBuilder.cs
@@ -575,7 +575,7 @@ public static PipelineStageDefinition<TInput, AggregateFacetResults> Facet<TInpu
             Ensure.IsNotNull(facets, nameof(facets));
             var outputSerializer = new AggregateFacetResultsSerializer(
                 facets.Select(f => f.Name),
-                facets.Select(f => f.OutputSerializer ?? BsonSerializer.SerializerRegistry.GetSerializer(f.OutputType)));
+                facets.Select(f => f.OutputSerializer ?? BsonSerializer.SerializerRegistry.GetSerializer(f.OutputType)));  //QUESTION What do we do? Do we delay the setting of the serializer..?
             var options = new AggregateFacetOptions<AggregateFacetResults> { OutputSerializer = outputSerializer };
             return Facet(facets, options);
         }
diff --git a/src/MongoDB.Driver/RenderArgs.cs b/src/MongoDB.Driver/RenderArgs.cs

Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ public IEnumerable<BsonCreatorMap> CreatorMaps`
`122`	`122`	`/// </summary>`
`123`	`123`	`public IConventionPack ConventionPack`
`124`	`124`	`{`
`125`		`- get { return BsonSerializer.DefaultSerializationDomain.ConventionRegistry.Lookup(_classType); } //TODO This is not completely correct, this should be eliminated.`
	`125`	`+ get { return BsonSerializer.DefaultSerializationDomain.ConventionRegistry.Lookup(_classType); }`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ public BsonMemberMap(BsonClassMap classMap, MemberInfo memberInfo)`
`56`	`56`	`{`
`57`	`57`	`_classMap = classMap;`
`58`	`58`	`_memberInfo = memberInfo;`
`59`		`- _memberType = BsonClassMap.GetMemberInfoType(memberInfo);`
	`59`	`+ _memberType = BsonClassMap.GetMemberInfoType(memberInfo); //FP This is more of a utility method, it can stay like this`
`60`	`60`	`_memberTypeIsBsonValue = typeof(BsonValue).GetTypeInfo().IsAssignableFrom(_memberType);`
`61`	`61`
`62`	`62`	`Reset();`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ public override void Serialize(BsonSerializationContext context, BsonSerializati`
`139`	`139`	`{`
`140`	`140`	`if (_cachedSerializer.ValueType != actualType)`
`141`	`141`	`{`
`142`		`- _cachedSerializer = BsonSerializer.LookupSerializer(actualType);`
	`142`	`+ _cachedSerializer = BsonSerializer.LookupSerializer(actualType); //FP This needs to go, need to access MongoDB.Bson internals to access domain`
`143`	`143`	`}`
`144`	`144`	`serializer = _cachedSerializer;`
`145`	`145`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ public void FormatSection(ClientBulkWriteOpsCommandMessageSection section, IBson`
`63`	`63`	`throw new ArgumentException("Writer must be an instance of BsonBinaryWriter.");`
`64`	`64`	`}`
`65`	`65`
`66`		`- _serializerRegistry = BsonSerializer.SerializerRegistry; //FP This needs to go`
	`66`	`+ _serializerRegistry = BsonSerializer.SerializerRegistry; //FP This needs to go, need to access MongoDB.Bson internals to access domain`
`67`	`67`	`var serializationContext = BsonSerializationContext.CreateRoot(binaryWriter);`
`68`	`68`	`_idsMap = section.IdsMap;`
`69`	`69`	`var stream = binaryWriter.BsonStream;`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public static IBsonSerializer GetSerializerForValueType(IBsonSerializer fieldSer`
`51`	`51`	`// serialize numeric values without converting them`
`52`	`52`	`if (fieldType.IsNumeric() && valueType.IsNumeric())`
`53`	`53`	`{`
`54`		`- var valueSerializer = BsonSerializer.SerializerRegistry.GetSerializer(valueType);`
	`54`	`+ var valueSerializer = BsonSerializer.SerializerRegistry.GetSerializer(valueType); //QUESTION What to we do here? We don't even use the input serializer registry. Probably ask Robert`
`55`	`55`	`if (HasStringRepresentation(fieldSerializer))`
`56`	`56`	`{`
`57`	`57`	`valueSerializer = WithStringRepresentation(valueSerializer);`
Original file line number	Diff line number	Diff line change
`@@ -243,7 +243,7 @@ public ReadPreference ReadPreference`
`243`	`243`	`/// </value>`
`244`	`244`	`public IBsonSerializerRegistry SerializerRegistry`
`245`	`245`	`{`
`246`		`- get { return BsonSerializer.SerializerRegistry; } //TODO This is wrong`
	`246`	`+ get { return BsonSerializer.SerializerRegistry; } //QUESTION What do we do in this case...? Given it's read only, we could ignore it? Also, why the immutable options have a serializer registry and the non-immutable options do not?`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public static TranslatedExpression Translate(TranslationContext context, UnaryEx`
`28`	`28`	`var arrayExpression = expression.Operand;`
`29`	`29`	`var arrayTranslation = ExpressionToAggregationExpressionTranslator.TranslateEnumerable(context, arrayExpression);`
`30`	`30`	`var ast = AstExpression.Size(arrayTranslation.Ast);`
`31`		`- var serializer = BsonSerializer.LookupSerializer(expression.Type);`
	`31`	`+ var serializer = context.SerializationDomain.LookupSerializer(expression.Type);`
`32`	`32`	`return new TranslatedExpression(expression, ast, serializer);`
`33`	`33`	`}`
`34`	`34`
Original file line number	Diff line number	Diff line change
`@@ -44,13 +44,13 @@ sourceExpression is UnaryExpression unarySourceExpression &&`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`var sourceTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, sourceExpression);`
`47`		`- return Translate(expression, sourceType, targetType, sourceTranslation);`
	`47`	`+ return Translate(expression, sourceType, targetType, sourceTranslation, context.SerializationDomain);`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`throw new ExpressionNotSupportedException(expression);`
`51`	`51`	`}`
`52`	`52`
`53`		`- private static TranslatedExpression Translate(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation)`
	`53`	`+ private static TranslatedExpression Translate(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation, IBsonSerializationDomain serializationDomain)`
`54`	`54`	`{`
`55`	`55`	`if (targetType == sourceType)`
`56`	`56`	`{`
`@@ -60,12 +60,12 @@ private static TranslatedExpression Translate(UnaryExpression expression, Type s`
`60`	`60`	`// from Nullable<T> must be handled before to Nullable<T>`
`61`	`61`	`if (IsConvertFromNullableType(sourceType))`
`62`	`62`	`{`
`63`		`- return TranslateConvertFromNullableType(expression, sourceType, targetType, sourceTranslation);`
	`63`	`+ return TranslateConvertFromNullableType(expression, sourceType, targetType, sourceTranslation, serializationDomain);`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`if (IsConvertToNullableType(targetType))`
`67`	`67`	`{`
`68`		`- return TranslateConvertToNullableType(expression, sourceType, targetType, sourceTranslation);`
	`68`	`+ return TranslateConvertToNullableType(expression, sourceType, targetType, sourceTranslation, serializationDomain);`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`// from here on we know there are no longer any Nullable<T> types involved`
`@@ -97,7 +97,7 @@ private static TranslatedExpression Translate(UnaryExpression expression, Type s`
`97`	`97`
`98`	`98`	`if (IsConvertToDerivedType(sourceType, targetType))`
`99`	`99`	`{`
`100`		`- return TranslateConvertToDerivedType(expression, targetType, sourceTranslation);`
	`100`	`+ return TranslateConvertToDerivedType(expression, targetType, sourceTranslation, serializationDomain);`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`var ast = sourceTranslation.Ast;`
`@@ -177,10 +177,9 @@ private static TranslatedExpression TranslateConvertToBaseType(UnaryExpression e`
`177`	`177`	`return new TranslatedExpression(expression, sourceTranslation.Ast, downcastingSerializer);`
`178`	`178`	`}`
`179`	`179`
`180`		`- private static TranslatedExpression TranslateConvertToDerivedType(UnaryExpression expression, Type targetType, TranslatedExpression sourceTranslation)`
	`180`	`+ private static TranslatedExpression TranslateConvertToDerivedType(UnaryExpression expression, Type targetType, TranslatedExpression sourceTranslation, IBsonSerializationDomain serializationDomain)`
`181`	`181`	`{`
`182`		`- var serializer = BsonSerializer.LookupSerializer(targetType);`
`183`		`-`
	`182`	`+ var serializer = serializationDomain.LookupSerializer(targetType);`
`184`	`183`	`return new TranslatedExpression(expression, sourceTranslation.Ast, serializer);`
`185`	`184`	`}`
`186`	`185`
`@@ -218,15 +217,15 @@ private static TranslatedExpression TranslateConvertEnumToUnderlyingType(UnaryEx`
`218`	`217`	`return new TranslatedExpression(expression, sourceTranslation.Ast, targetSerializer);`
`219`	`218`	`}`
`220`	`219`
`221`		`- private static TranslatedExpression TranslateConvertFromNullableType(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation)`
	`220`	`+ private static TranslatedExpression TranslateConvertFromNullableType(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation, IBsonSerializationDomain serializationDomain)`
`222`	`221`	`{`
`223`	`222`	`if (sourceType.IsNullable(out var sourceValueType))`
`224`	`223`	`{`
`225`	`224`	`var (sourceVarBinding, sourceAst) = AstExpression.UseVarIfNotSimple("source", sourceTranslation.Ast);`
`226`	`225`	`var sourceNullableSerializer = (INullableSerializer)sourceTranslation.Serializer;`
`227`	`226`	`var sourceValueSerializer = sourceNullableSerializer.ValueSerializer;`
`228`	`227`	`var sourceValueTranslation = new TranslatedExpression(expression.Operand, sourceAst, sourceValueSerializer);`
`229`		`- var convertTranslation = Translate(expression, sourceValueType, targetType, sourceValueTranslation);`
	`228`	`+ var convertTranslation = Translate(expression, sourceValueType, targetType, sourceValueTranslation, serializationDomain);`
`230`	`229`
`231`	`230`	`// note: we would have liked to throw a query execution error here if the value is null and the target type is not nullable but there is no way to do that in MQL`
`232`	`231`	`// so we just return null instead and the user must check for null themselves if they want to define what happens when the value is null`
`@@ -242,7 +241,7 @@ private static TranslatedExpression TranslateConvertFromNullableType(UnaryExpres`
`242`	`241`	`throw new ExpressionNotSupportedException(expression, because: "sourceType is not nullable");`
`243`	`242`	`}`
`244`	`243`
`245`		`- private static TranslatedExpression TranslateConvertToNullableType(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation)`
	`244`	`+ private static TranslatedExpression TranslateConvertToNullableType(UnaryExpression expression, Type sourceType, Type targetType, TranslatedExpression sourceTranslation, IBsonSerializationDomain serializationDomain)`
`246`	`245`	`{`
`247`	`246`	`if (sourceType.IsNullable())`
`248`	`247`	`{`
`@@ -252,7 +251,7 @@ private static TranslatedExpression TranslateConvertToNullableType(UnaryExpressi`
`252`	`251`
`253`	`252`	`if (targetType.IsNullable(out var targetValueType))`
`254`	`253`	`{`
`255`		`- var convertTranslation = Translate(expression, sourceType, targetValueType, sourceTranslation);`
	`254`	`+ var convertTranslation = Translate(expression, sourceType, targetValueType, sourceTranslation, serializationDomain);`
`256`	`255`	`var nullableSerializer = NullableSerializer.Create(convertTranslation.Serializer);`
`257`	`256`	`return new TranslatedExpression(expression, convertTranslation.Ast, nullableSerializer);`
`258`	`257`	`}`