Update TryGetEntityName method

Author: maca88

src/NHibernate.Test/Async/Linq/SelectionTests.cs

@@ -309,6 +309,10 @@ public async Task CanProjectWithCastAsync()
 
 			var names5 = await (db.Users.Select(p => new { p1 = (p as IUser).Name }).ToListAsync());
 			Assert.AreEqual(3, names5.Count);
+
+			var names6 = await (db.Users.Select(p => new { p1 = (long) p.Id }).ToListAsync());
+			Assert.AreEqual(3, names6.Count);
+
 			// ReSharper restore RedundantCast
 		}
 

src/NHibernate.Test/Linq/SelectionTests.cs

@@ -348,6 +348,10 @@ public void CanProjectWithCast()
 
 			var names5 = db.Users.Select(p => new { p1 = (p as IUser).Name }).ToList();
 			Assert.AreEqual(3, names5.Count);
+
+			var names6 = db.Users.Select(p => new { p1 = (long) p.Id }).ToList();
+			Assert.AreEqual(3, names6.Count);
+
 			// ReSharper restore RedundantCast
 		}
 

src/NHibernate/Linq/Visitors/HqlGeneratorExpressionVisitor.cs

@@ -673,34 +673,23 @@ private IType GetType(Expression expression)
 			}
 
 			// Try to get the mapped type for the member as it may be a non default one
-			var entityName = TryGetEntityName(memberExpression);
+			var entityName = ExpressionsHelper.TryGetEntityName(_parameters.SessionFactory, memberExpression, out var memberPath);
 			if (entityName == null)
 			{
 				return TypeFactory.GetDefaultTypeFor(expression.Type); // Not mapped
 			}
 
 			var persister = _parameters.SessionFactory.GetEntityPersister(entityName);
-			var index = persister.EntityMetamodel.GetPropertyIndexOrNull(memberExpression.Member.Name);
-			return !index.HasValue
-				? TypeFactory.GetDefaultTypeFor(expression.Type) // Not mapped
-				: persister.EntityMetamodel.PropertyTypes[index.Value];
-		}
-
-		private string TryGetEntityName(MemberExpression memberExpression)
-		{
-			System.Type entityType;
-			// Try to get the actual entity type from the query source if possbile as member can be declared
-			// in a base type
-			if (memberExpression.Expression is QuerySourceReferenceExpression querySourceReferenceExpression)
+			var type = persister.EntityMetamodel.GetIdentifierPropertyType(memberPath);
+			if (type != null)
 			{
-				entityType = querySourceReferenceExpression.Type;
-			}
-			else
-			{
-				entityType = memberExpression.Member.ReflectedType;
+				return type;
 			}
 
-			return _parameters.SessionFactory.TryGetGuessEntityName(entityType);
+			var index = persister.EntityMetamodel.GetPropertyIndexOrNull(memberPath);
+			return !index.HasValue
+				? TypeFactory.GetDefaultTypeFor(expression.Type) // Not mapped
+				: persister.EntityMetamodel.PropertyTypes[index.Value];
 		}
 	}
 }

src/NHibernate/Tuple/Entity/EntityMetamodel.cs

@@ -50,6 +50,7 @@ public class EntityMetamodel
 		private readonly CascadeStyle[] cascadeStyles;
 
 		private readonly Dictionary<string, int?> propertyIndexes = new Dictionary<string, int?>();
+		private readonly IDictionary<string, IType> _identifierPropertyTypes = new Dictionary<string, IType>();
 		private readonly bool hasCollections;
 		private readonly bool hasMutableProperties;
 		private readonly bool hasLazyProperties;
@@ -93,6 +94,7 @@ public EntityMetamodel(PersistentClass persistentClass, ISessionFactoryImplement
 
 			identifierProperty = PropertyFactory.BuildIdentifierProperty(persistentClass,
 			                                                             sessionFactory.GetIdentifierGenerator(rootName));
+			MapIdentifierPropertyTypes(identifierProperty);
 
 			versioned = persistentClass.IsVersioned;
 
@@ -411,13 +413,42 @@ private bool HasPartialUpdateComponentGeneration(Mapping.Component component)
 
 		private void MapPropertyToIndex(Mapping.Property prop, int i)
 		{
-			propertyIndexes[prop.Name] = i;
-			Mapping.Component comp = prop.Value as Mapping.Component;
-			if (comp != null)
+			MapPropertyToIndex(null, prop, i);
+		}
+
+		private void MapPropertyToIndex(string path, Mapping.Property prop, int i)
+		{
+			propertyIndexes[!string.IsNullOrEmpty(path) ? $"{path}.{prop.Name}" : prop.Name] = i;
+			if (!(prop.Value is Mapping.Component comp))
+			{
+				return;
+			}
+
+			foreach (var subprop in comp.PropertyIterator)
+			{
+				MapPropertyToIndex(!string.IsNullOrEmpty(path) ? $"{path}.{prop.Name}" : prop.Name, subprop, i);
+			}
+		}
+
+		private void MapIdentifierPropertyTypes(IdentifierProperty identifier)
+		{
+			MapIdentifierPropertyTypes(identifier.Name, identifier.Type);
+		}
+
+		private void MapIdentifierPropertyTypes(string path, IType propertyType)
+		{
+			if (!string.IsNullOrEmpty(path))
+			{
+				_identifierPropertyTypes[path] = propertyType;
+			}
+
+			if (propertyType is IAbstractComponentType componentType)
 			{
-				foreach (Mapping.Property subprop in comp.PropertyIterator)
+				for (var i = 0; i < componentType.PropertyNames.Length; i++)
 				{
-					propertyIndexes[prop.Name + '.' + subprop.Name] = i;
+					MapIdentifierPropertyTypes(
+						!string.IsNullOrEmpty(path) ? $"{path}.{componentType.PropertyNames[i]}" : componentType.PropertyNames[i],
+						componentType.Subtypes[i]);
 				}
 			}
 		}
@@ -536,6 +567,11 @@ public int GetPropertyIndex(string propertyName)
 				return null;
 		}
 
+		internal IType GetIdentifierPropertyType(string memberPath)
+		{
+			return _identifierPropertyTypes.TryGetValue(memberPath, out var propertyType) ? propertyType : null;
+		}
+
 		public bool HasCollections
 		{
 			get { return hasCollections; }

src/NHibernate/Util/ExpressionsHelper.cs

@@ -1,6 +1,10 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System;
+using NHibernate.Engine;
+using NHibernate.Type;
+using Remotion.Linq.Clauses;
+using Remotion.Linq.Clauses.Expressions;
 
 namespace NHibernate.Util
 {
@@ -15,5 +19,64 @@ public static MemberInfo DecodeMemberAccessExpression<TEntity, TResult>(Expressi
 			}
 			return ((MemberExpression)expression.Body).Member;
 		}
+
+		internal static string TryGetEntityName(ISessionFactoryImplementor sessionFactory, MemberExpression memberExpression, out string memberPath)
+		{
+			string entityName;
+			memberPath = memberExpression.Member.Name;
+			// When having components we need to go though them in order to find the entity
+			while (memberExpression.Expression is MemberExpression subMemberExpression)
+			{
+				// In some cases we can encounter a property representing the entity e.g. [_0].Customer.CustomerId
+				if (subMemberExpression.NodeType == ExpressionType.MemberAccess)
+				{
+					entityName = sessionFactory.TryGetGuessEntityName(memberExpression.Member.ReflectedType);
+					if (entityName != null)
+					{
+						return entityName;
+					}
+				}
+
+				memberPath = $"{subMemberExpression.Member.Name}.{memberPath}"; // Build a path that can be used to get the property form the entity metadata
+				memberExpression = subMemberExpression;
+			}
+
+			// Try to get the actual entity type from the query source if possbile as member can be declared
+			// in a base type
+			if (memberExpression.Expression is QuerySourceReferenceExpression querySourceReferenceExpression)
+			{
+				entityName = sessionFactory.TryGetGuessEntityName(querySourceReferenceExpression.Type);
+				if (entityName != null ||
+					!(querySourceReferenceExpression.ReferencedQuerySource is IFromClause fromClause) ||
+					!(fromClause.FromExpression is MemberExpression subMemberExpression))
+				{
+					return entityName;
+				}
+
+				// When the member type is not the one that is mapped (e.g. interface) we have to find the first
+				// mapped entity and calculate the entity name from there
+				entityName = TryGetEntityName(sessionFactory, subMemberExpression, out var subMemberPath);
+				if (entityName == null)
+				{
+					return null;
+				}
+
+				var persister = sessionFactory.GetEntityPersister(entityName);
+				var index = persister.EntityMetamodel.GetPropertyIndexOrNull(subMemberPath);
+				IAssociationType associationType;
+				if (index.HasValue)
+				{
+					associationType = persister.PropertyTypes[index.Value] as IAssociationType;
+				}
+				else
+				{
+					associationType = persister.EntityMetamodel.GetIdentifierPropertyType(subMemberPath) as IAssociationType;
+				}
+
+				return associationType?.GetAssociatedEntityName(sessionFactory);
+			}
+
+			return sessionFactory.TryGetGuessEntityName(memberExpression.Member.ReflectedType);
+		}
 	}
-}
+}