Process classes accordingly to inheritance path in mapping by code

In some rare cases the old code did not work as it was intended because
comparison algorithm doesn't always compare the types directly, but
instead the comparison can be made through a 3rd type.

Adapt the sample provided by @rrutkows to demonstrate the issue.

Author: hazzik

src/NHibernate.Test/NHSpecificTest/NH2931/Fixture.cs

@@ -1,5 +1,4 @@
-using System;
-using NHibernate.Mapping.ByCode;
+using NHibernate.Mapping.ByCode;
 using NUnit.Framework;
 using System.Linq;
 
@@ -12,21 +11,28 @@ public class MappingByCodeTest
 		public void CompiledMappings_ShouldNotDependOnAddedOrdering_AddedBy_AddMapping()
 		{
 			var mapper = new ModelMapper();
-			mapper.AddMapping<EntityMapping>();
-			mapper.AddMapping<DerivedClassMapping>();
-			mapper.AddMapping<BaseClassMapping>();
+			mapper.AddMapping<AMapping>();
+			mapper.AddMapping<BMapping>();
+			mapper.AddMapping<CMapping>();
+			mapper.AddMapping<DMapping>();
+			mapper.AddMapping<EMapping>();
+			mapper.AddMapping<FMapping>();
+			mapper.AddMapping<GMapping>();
 			var config = TestConfigurationHelper.GetDefaultConfiguration();
 			Assert.DoesNotThrow(() => config.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities()));
 		}
 
 		[Test]
 		public void CompiledMappings_ShouldNotDependOnAddedOrdering_AddedBy_AddMappings()
 		{
+			var mappings =
+				typeof(MappingByCodeTest)
+					.Assembly
+					.GetExportedTypes()
+					//only add our test entities/mappings
+					.Where(t => t.Namespace == typeof(MappingByCodeTest).Namespace && t.Name.EndsWith("Mapping"));
 			var mapper = new ModelMapper();
-			mapper.AddMappings(typeof(EntityMapping).Assembly
-				.GetExportedTypes()
-				//only add our test entities/mappings
-				.Where(t => t.Namespace == typeof(MappingByCodeTest).Namespace));
+			mapper.AddMappings(mappings);
 			var config = TestConfigurationHelper.GetDefaultConfiguration();
 			Assert.DoesNotThrow(() => config.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities()));
 		}

src/NHibernate.Test/NHSpecificTest/NH2931/Mappings.cs

@@ -1,37 +1,18 @@
-using NHibernate.Mapping.ByCode;
-using NHibernate.Mapping.ByCode.Conformist;
+using NHibernate.Mapping.ByCode.Conformist;
 
 namespace NHibernate.Test.NHSpecificTest.NH2931
 {
-    public class EntityMapping : ClassMapping<Entity>
-    {
-        public EntityMapping()
-        {
-            Id(i => i.Id, m => m.Generator(Generators.GuidComb));
-        }
-    }
-    //NOTE: tests may work if the order of mappings is
-    // 1) BaseClassMapping
-    // 2) DerivedClassMapping
-    //but they always fail when
-    // 1) DerivedClassMapping
-    // 2) BaseClassMapping
-    //MappingByCodeTest.CompiledMappings_ShouldNotDependOnAddedOrdering_AddedBy_AddMapping
-    // explicitly forces the first ordering to occur, but the most common use is simply
-    // typeof(SomeEntity).Assembly.GetTypes() to register everything; as shown in 
-    //MappingByCodeTest.CompiledMappings_ShouldNotDependOnAddedOrdering_AddedBy_AddMappings
-    public class DerivedClassMapping : JoinedSubclassMapping<DerivedClass>
-    {
-        public DerivedClassMapping()
-        {
-            Property(p => p.DerivedProperty);
-        }
-    }
-    public class BaseClassMapping : JoinedSubclassMapping<BaseClass>
-    {
-        public BaseClassMapping()
-        {
-            Property(p => p.BaseProperty);
-        }
-    }
+	public class AMapping : JoinedSubclassMapping<A> {}
+
+	public class BMapping : ClassMapping<B> {}
+
+	public class CMapping : JoinedSubclassMapping<C> {}
+
+	public class DMapping : JoinedSubclassMapping<D> {}
+
+	public class EMapping : JoinedSubclassMapping<E> {}
+
+	public class FMapping : JoinedSubclassMapping<F> {}
+
+	public class GMapping : ClassMapping<G> {}
 }

src/NHibernate.Test/NHSpecificTest/NH2931/Models.cs

@@ -1,17 +1,16 @@
-using System;
-
-namespace NHibernate.Test.NHSpecificTest.NH2931
+namespace NHibernate.Test.NHSpecificTest.NH2931
 {
-    public abstract class Entity
-    {
-        public Guid Id { get; private set; }
-    }
-    public class BaseClass : Entity
-    {
-        public string BaseProperty { get; set; }
-    }
-    public class DerivedClass : BaseClass
-    {
-        public string DerivedProperty { get; set; }
-    }
+	public class A : F{ }
+
+	public class B { }
+
+	public class C : B { }
+
+	public class D : B { }
+
+	public class E : F { }
+
+	public class F : G { }
+
+	public class G { }
 }

src/NHibernate/Mapping/ByCode/ModelMapper.cs

@@ -549,9 +549,7 @@ public HbmMapping CompileMappingFor(IEnumerable<System.Type> types)
 				throw new ArgumentNullException("types");
 			}
 
-			var typeToMap = types.Distinct()
-								 .OrderBy(x => x, new TypeHierarchyComparer())
-								 .ToList();
+			var typeToMap = OrderTypesByHierarchy(types);
 
 			string defaultAssemblyName = null;
 			string defaultNamespace = null;
@@ -583,9 +581,7 @@ public IEnumerable<HbmMapping> CompileMappingForEach(IEnumerable<System.Type> ty
 			{
 				throw new ArgumentNullException("types");
 			}
-			var typeToMap = types.Distinct()
-								 .OrderBy(x => x, new TypeHierarchyComparer())
-								 .ToList();
+			var typeToMap = OrderTypesByHierarchy(types);
 
 			//NH-2831: always use the full name of the assembly because it may come from GAC
 			foreach (var type in RootClasses(typeToMap))
@@ -1809,15 +1805,17 @@ public IEnumerable<HbmMapping> CompileMappingForEachExplicitlyAddedEntity()
 			return CompileMappingForEach(customizerHolder.GetAllCustomizedEntities());
 		}
 
-		private class TypeHierarchyComparer : IComparer<System.Type>
+		private static List<System.Type> OrderTypesByHierarchy(IEnumerable<System.Type> types)
 		{
-			public int Compare(System.Type x, System.Type y)
+			var typesCache = new HashSet<System.Type>(types);
+
+			var result = new List<System.Type>(typesCache.Count);
+			while (typesCache.Count > 0)
 			{
-				if (x == y) return 0;
-				if (x.IsAssignableFrom(y)) return -1;
-				if (y.IsAssignableFrom(x)) return 1;
-				return 0;
+				var type = typesCache.First();
+				result.AddRange(type.GetHierarchyFromBase().Where(baseType => typesCache.Remove(baseType)));
 			}
+			return result;
 		}
 	}
 }