Various corrections

Author: papafe

src/MongoDB.Bson/Serialization/BsonClassMap.cs

@@ -278,82 +278,82 @@ public static Type GetMemberInfoType(MemberInfo memberInfo)
         /// </summary>
         /// <returns>All registered class maps.</returns>
         public static IEnumerable<BsonClassMap> GetRegisteredClassMaps() =>
-            BsonSerializer.DefaultDomain.ClassMapDomain.GetRegisteredClassMaps();
+            BsonSerializer.DefaultDomain.BsonClassMap.GetRegisteredClassMaps(); //TODO Used only in tests
 
         /// <summary>
         /// Checks whether a class map is registered for a type.
         /// </summary>
         /// <param name="type">The type to check.</param>
         /// <returns>True if there is a class map registered for the type.</returns>
         public static bool IsClassMapRegistered(Type type) =>
-            BsonSerializer.DefaultDomain.ClassMapDomain.IsClassMapRegistered(type);
+            BsonSerializer.DefaultDomain.BsonClassMap.IsClassMapRegistered(type); //TODO Used only in tests
 
         /// <summary>
         /// Looks up a class map (will AutoMap the class if no class map is registered).
         /// </summary>
         /// <param name="classType">The class type.</param>
         /// <returns>The class map.</returns>
         public static BsonClassMap LookupClassMap(Type classType) =>
-            BsonSerializer.DefaultDomain.ClassMapDomain.LookupClassMap(classType);
+            BsonSerializer.DefaultDomain.BsonClassMap.LookupClassMap(classType);
 
         /// <summary>
         /// Creates and registers a class map.
         /// </summary>
         /// <typeparam name="TClass">The class.</typeparam>
         /// <returns>The class map.</returns>
-        public static BsonClassMap<TClass> RegisterClassMap<TClass>()=>
-            BsonSerializer.DefaultDomain.ClassMapDomain.RegisterClassMap<TClass>();
+        public static BsonClassMap<TClass> RegisterClassMap<TClass>()=>  //TODO Used only in tests
+            BsonSerializer.DefaultDomain.BsonClassMap.RegisterClassMap<TClass>();
 
         /// <summary>
         /// Creates and registers a class map.
         /// </summary>
         /// <typeparam name="TClass">The class.</typeparam>
         /// <param name="classMapInitializer">The class map initializer.</param>
         /// <returns>The class map.</returns>
-        public static BsonClassMap<TClass> RegisterClassMap<TClass>(Action<BsonClassMap<TClass>> classMapInitializer)
-            => BsonSerializer.DefaultDomain.ClassMapDomain.RegisterClassMap(classMapInitializer);
+        public static BsonClassMap<TClass> RegisterClassMap<TClass>(Action<BsonClassMap<TClass>> classMapInitializer)  //TODO Used only in tests
+            => BsonSerializer.DefaultDomain.BsonClassMap.RegisterClassMap(classMapInitializer);
 
         /// <summary>
         /// Registers a class map.
         /// </summary>
         /// <param name="classMap">The class map.</param>
-        public static void RegisterClassMap(BsonClassMap classMap)
-            => BsonSerializer.DefaultDomain.ClassMapDomain.RegisterClassMap(classMap);
+        public static void RegisterClassMap(BsonClassMap classMap)  //TODO Used only in tests
+            => BsonSerializer.DefaultDomain.BsonClassMap.RegisterClassMap(classMap);
 
         /// <summary>
         /// Registers a class map if it is not already registered.
         /// </summary>
         /// <typeparam name="TClass">The class.</typeparam>
         /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
-        public static bool TryRegisterClassMap<TClass>()
-            => BsonSerializer.DefaultDomain.ClassMapDomain.TryRegisterClassMap<TClass>();
+        public static bool TryRegisterClassMap<TClass>()  //TODO Used only in tests
+            => BsonSerializer.DefaultDomain.BsonClassMap.TryRegisterClassMap<TClass>();
 
         /// <summary>
         /// Registers a class map if it is not already registered.
         /// </summary>
         /// <typeparam name="TClass">The class.</typeparam>
         /// <param name="classMap">The class map.</param>
         /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
-        public static bool TryRegisterClassMap<TClass>(BsonClassMap<TClass> classMap)
-            => BsonSerializer.DefaultDomain.ClassMapDomain.TryRegisterClassMap(classMap);
+        public static bool TryRegisterClassMap<TClass>(BsonClassMap<TClass> classMap)  //TODO Used only in tests
+            => BsonSerializer.DefaultDomain.BsonClassMap.TryRegisterClassMap(classMap);
 
         /// <summary>
         /// Registers a class map if it is not already registered.
         /// </summary>
         /// <typeparam name="TClass">The class.</typeparam>
         /// <param name="classMapInitializer">The class map initializer (only called if the class map is not already registered).</param>
         /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
-        public static bool TryRegisterClassMap<TClass>(Action<BsonClassMap<TClass>> classMapInitializer)
-            => BsonSerializer.DefaultDomain.ClassMapDomain.TryRegisterClassMap(classMapInitializer);
+        public static bool TryRegisterClassMap<TClass>(Action<BsonClassMap<TClass>> classMapInitializer)  //TODO Used only in tests
+            => BsonSerializer.DefaultDomain.BsonClassMap.TryRegisterClassMap(classMapInitializer);
 
         /// <summary>
         /// Registers a class map if it is not already registered.
         /// </summary>
         /// <typeparam name="TClass">The class.</typeparam>
         /// <param name="classMapFactory">The class map factory (only called if the class map is not already registered).</param>
         /// <returns>True if this call registered the class map, false if the class map was already registered.</returns>
-        public static bool TryRegisterClassMap<TClass>(Func<BsonClassMap<TClass>> classMapFactory)
-            => BsonSerializer.DefaultDomain.ClassMapDomain.TryRegisterClassMap(classMapFactory);
+        public static bool TryRegisterClassMap<TClass>(Func<BsonClassMap<TClass>> classMapFactory)  //TODO Used only in tests
+            => BsonSerializer.DefaultDomain.BsonClassMap.TryRegisterClassMap(classMapFactory);
 
         // public methods
         /// <summary>
@@ -454,7 +454,7 @@ private BsonClassMap Freeze(FreezeContext context)
                         {
                             if (_baseClassMap == null)
                             {
-                                _baseClassMap = LookupClassMap(baseType);
+                                _baseClassMap = context.SerializationDomain.BsonClassMap.LookupClassMap(baseType);
                             }
                             _baseClassMap.Freeze(context);  //TODO This is not necessary, because LookupClassMap will only return a frozen class map
                             _discriminatorIsRequired |= _baseClassMap._discriminatorIsRequired;
@@ -557,7 +557,7 @@ private BsonClassMap Freeze(FreezeContext context)
                             while (context.KnownTypesQueue.Count != 0)
                             {
                                 var knownType = context.KnownTypesQueue.Dequeue();
-                                LookupClassMap(knownType); // will AutoMap and/or Freeze knownType if necessary
+                                context.SerializationDomain.BsonClassMap.LookupClassMap(knownType); // will AutoMap and/or Freeze knownType if necessary
                             }
                         }
                     }

src/MongoDB.Bson/Serialization/BsonClassMapSerializationProvider.cs

@@ -41,7 +41,7 @@ public override IBsonSerializer GetSerializer(Type type, IBsonSerializerRegistry
                 !typeof(Array).GetTypeInfo().IsAssignableFrom(type) &&
                 !typeof(Enum).GetTypeInfo().IsAssignableFrom(type))
             {
-                var classMap = BsonClassMap.LookupClassMap(type);
+                var classMap = BsonClassMap.LookupClassMap(type);  //TODO We need to find a way to pass the domain here
                 var classMapSerializerDefinition = typeof(BsonClassMapSerializer<>);
                 var classMapSerializerType = classMapSerializerDefinition.MakeGenericType(type);
                 return (IBsonSerializer)Activator.CreateInstance(classMapSerializerType, classMap);

src/MongoDB.Bson/Serialization/BsonSerializationDomain.cs

@@ -732,7 +732,7 @@ public void Serialize(
             serializer.Serialize(context, args, value);
         }
 
-        public IBsonClassMapDomain ClassMapDomain => _classMapDomain;
+        public IBsonClassMapDomain BsonClassMap => _classMapDomain;
 
         /// <summary>
         /// Tries to register a serializer for a type.

src/MongoDB.Bson/Serialization/Conventions/HierarchicalDiscriminatorConvention.cs

@@ -48,7 +48,7 @@ public override BsonValue GetDiscriminator(Type nominalType, Type actualType) =>
         public override BsonValue GetDiscriminator(Type nominalType, Type actualType, IBsonSerializationDomain domain)
         {
             // TODO: this isn't quite right, not all classes are serialized using  a class map serializer
-            var classMap = BsonClassMap.LookupClassMap(actualType);
+            var classMap = domain.BsonClassMap.LookupClassMap(actualType);
             if (actualType != nominalType || classMap.DiscriminatorIsRequired || classMap.HasRootClass)
             {
                 if (classMap.HasRootClass && !classMap.IsRootClass)

src/MongoDB.Bson/Serialization/Conventions/ScalarDiscriminatorConvention.cs

@@ -46,7 +46,7 @@ public override BsonValue GetDiscriminator(Type nominalType, Type actualType) =>
         public override BsonValue GetDiscriminator(Type nominalType, Type actualType, IBsonSerializationDomain domain)
         {
             // TODO: this isn't quite right, not all classes are serialized using a class map serializer
-            var classMap = BsonClassMap.LookupClassMap(actualType);
+            var classMap = domain.BsonClassMap.LookupClassMap(actualType);
             if (actualType != nominalType || classMap.DiscriminatorIsRequired)
             {
                 return classMap.Discriminator;

src/MongoDB.Bson/Serialization/IBsonSerializationDomain.cs

@@ -288,7 +288,7 @@ void Serialize(
         /// <summary>
         /// //TODO
         /// </summary>
-        IBsonClassMapDomain ClassMapDomain { get; }
+        IBsonClassMapDomain BsonClassMap { get; }
     }
 
     internal interface IBsonSerializationDomainInternal : IBsonSerializationDomain