NH-3850 - Fix for polymorphic Linq query results aggregators failures.

Author: fredericDelaporte

src/NHibernate/Linq/EnumerableHelper.cs

@@ -65,15 +65,15 @@ public static MemberInfo GetProperty<TSource, TResult>(Expression<Func<TSource,
 			return ReflectHelper.GetProperty(property);
 		}
 	}
-	
+
 	[Obsolete("Please use NHibernate.Util.ReflectHelper instead")]
 	public static class EnumerableHelper
 	{
 		public static MethodInfo GetMethod(string name, System.Type[] parameterTypes)
 		{
 			return typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public)
 				.Where(m => m.Name == name &&
-							ParameterTypesMatch(m.GetParameters(), parameterTypes))
+					ReflectHelper.ParameterTypesMatch(m.GetParameters(), parameterTypes))
 				.Single();
 		}
 
@@ -83,35 +83,9 @@ public static MethodInfo GetMethod(string name, System.Type[] parameterTypes, Sy
 				.Where(m => m.Name == name &&
 							m.ContainsGenericParameters &&
 							m.GetGenericArguments().Count() == genericTypeParameters.Length &&
-							ParameterTypesMatch(m.GetParameters(), parameterTypes))
+							ReflectHelper.ParameterTypesMatch(m.GetParameters(), parameterTypes))
 				.Single()
 				.MakeGenericMethod(genericTypeParameters);
 		}
-
-		private static bool ParameterTypesMatch(ParameterInfo[] parameters, System.Type[] types)
-		{
-			if (parameters.Length != types.Length)
-			{
-				return false;
-			}
-
-			for (int i = 0; i < parameters.Length; i++)
-			{
-				if (parameters[i].ParameterType == types[i])
-				{
-					continue;
-				}
-
-				if (parameters[i].ParameterType.ContainsGenericParameters && types[i].ContainsGenericParameters &&
-					parameters[i].ParameterType.GetGenericArguments().Length == types[i].GetGenericArguments().Length)
-				{
-					continue;
-				}
-
-				return false;
-			}
-
-			return true;
-		}
 	}
 }

src/NHibernate/Linq/ExpressionToHqlTranslationResults.cs

@@ -1,26 +1,30 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Linq;
 using System.Linq.Expressions;
-using System.Reflection;
 using NHibernate.Hql.Ast;
 using NHibernate.Type;
 
 namespace NHibernate.Linq
 {
 	public class ExpressionToHqlTranslationResults
 	{
-		public HqlTreeNode Statement { get; private set; }
-		public ResultTransformer ResultTransformer { get; private set; }
-		public Delegate PostExecuteTransformer { get; private set; }
-		public List<Action<IQuery, IDictionary<string, Tuple<object, IType>>>> AdditionalCriteria { get; private set; }
+		public HqlTreeNode Statement { get;  }
+		public ResultTransformer ResultTransformer { get; }
+		public Delegate PostExecuteTransformer { get; }
+		public List<Action<IQuery, IDictionary<string, Tuple<object, IType>>>> AdditionalCriteria { get; }
+
+		/// <summary>
+		/// If execute result type does not match expected final result type (implying a post execute transformer
+		/// will yield expected result type), the intermediate execute type.
+		/// </summary>
+		public System.Type ExecuteResultTypeOverride { get; }
 
 		public ExpressionToHqlTranslationResults(HqlTreeNode statement, 
 			IList<LambdaExpression> itemTransformers, 
 			IList<LambdaExpression> listTransformers,
 			IList<LambdaExpression> postExecuteTransformers,
-			List<Action<IQuery, IDictionary<string, Tuple<object, IType>>>> additionalCriteria)
+			List<Action<IQuery, IDictionary<string, Tuple<object, IType>>>> additionalCriteria,
+			System.Type executeResultTypeOverride)
 		{
 			Statement = statement;
 
@@ -35,6 +39,7 @@ public ExpressionToHqlTranslationResults(HqlTreeNode statement,
 			}
 
 			AdditionalCriteria = additionalCriteria;
+			ExecuteResultTypeOverride = executeResultTypeOverride;
 		}
 
 		private static TDelegate MergeLambdasAndCompile<TDelegate>(IList<LambdaExpression> itemTransformers) 

src/NHibernate/Linq/Functions/QueryableGenerator.cs

@@ -53,10 +53,10 @@ public class AllHqlGenerator : BaseHqlGeneratorForMethod
 		public AllHqlGenerator()
 		{
 			SupportedMethods = new[]
-			                   	{
-			                   		ReflectHelper.GetMethodDefinition(() => Queryable.All<object>(null, null)),
-			                   		ReflectHelper.GetMethodDefinition(() => Enumerable.All<object>(null, null))
-			                   	};
+			{
+				ReflectHelper.GetMethodDefinition(() => Queryable.All<object>(null, null)),
+				ReflectHelper.GetMethodDefinition(() => Enumerable.All<object>(null, null))
+			};
 		}
 
 		public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)

src/NHibernate/Linq/IntermediateHqlTree.cs

@@ -50,7 +50,13 @@ public HqlTreeNode Root
 			}
 		}
 
-		public HqlTreeBuilder TreeBuilder { get; private set; }
+		/// <summary>
+		/// If execute result type does not match expected final result type (implying a post execute transformer
+		/// will yield expected result type), the intermediate execute type.
+		/// </summary>
+		public System.Type ExecuteResultTypeOverride { get; set; }
+
+		public HqlTreeBuilder TreeBuilder { get; }
 
 		public IntermediateHqlTree(bool root)
 		{
@@ -62,10 +68,11 @@ public IntermediateHqlTree(bool root)
 		public ExpressionToHqlTranslationResults GetTranslation()
 		{
 			return new ExpressionToHqlTranslationResults(Root,
-														 _itemTransformers,
-														 _listTransformers,
-														 _postExecuteTransformers,
-														 _additionalCriteria);
+				_itemTransformers,
+				_listTransformers,
+				_postExecuteTransformers,
+				_additionalCriteria,
+				ExecuteResultTypeOverride);
 		}
 
 		public void AddDistinctRootOperator()

src/NHibernate/Linq/NhLinqExpression.cs

@@ -13,20 +13,20 @@ namespace NHibernate.Linq
 {
 	public class NhLinqExpression : IQueryExpression
 	{
-		public string Key { get; private set; }
+		public string Key { get; }
 
 		public System.Type Type { get; private set; }
 
 		public IList<NamedParameterDescriptor> ParameterDescriptors { get; private set; }
 
-		public NhLinqExpressionReturnType ReturnType { get; private set; }
+		public NhLinqExpressionReturnType ReturnType { get; }
 
-		public IDictionary<string, Tuple<object, IType>> ParameterValuesByName { get; private set; }
+		public IDictionary<string, Tuple<object, IType>> ParameterValuesByName { get; }
 
 		public ExpressionToHqlTranslationResults ExpressionToHqlTranslationResults { get; private set; }
 
-		internal Expression _expression;
-		internal IDictionary<ConstantExpression, NamedParameter> _constantToParameterMap;
+		private Expression _expression;
+		private readonly IDictionary<ConstantExpression, NamedParameter> _constantToParameterMap;
 
 		public NhLinqExpression(Expression expression, ISessionFactoryImplementor sessionFactory)
 		{
@@ -64,7 +64,10 @@ public IASTNode Translate(ISessionFactoryImplementor sessionFactory, bool filter
 			var queryModel = NhRelinqQueryParser.Parse(_expression);
 			var visitorParameters = new VisitorParameters(sessionFactory, _constantToParameterMap, requiredHqlParameters, querySourceNamer);
 
-			ExpressionToHqlTranslationResults = QueryModelVisitor.GenerateHqlQuery(queryModel, visitorParameters, true);
+			ExpressionToHqlTranslationResults = QueryModelVisitor.GenerateHqlQuery(queryModel, visitorParameters, true, ReturnType);
+
+			if (ExpressionToHqlTranslationResults.ExecuteResultTypeOverride != null)
+				Type = ExpressionToHqlTranslationResults.ExecuteResultTypeOverride;
 
 			ParameterDescriptors = requiredHqlParameters.AsReadOnly();
 
@@ -75,6 +78,8 @@ internal void CopyExpressionTranslation(NhLinqExpression other)
 		{
 			ExpressionToHqlTranslationResults = other.ExpressionToHqlTranslationResults;
 			ParameterDescriptors = other.ParameterDescriptors;
+			// Type could have been overridden by translation.
+			Type = other.Type;
 		}
 	}
 }

src/NHibernate/Linq/Visitors/HqlGeneratorExpressionTreeVisitor.cs

@@ -542,7 +542,7 @@ protected HqlTreeNode VisitConditionalExpression(ConditionalExpression expressio
 
 		protected HqlTreeNode VisitSubQueryExpression(SubQueryExpression expression)
 		{
-			ExpressionToHqlTranslationResults query = QueryModelVisitor.GenerateHqlQuery(expression.QueryModel, _parameters, false);
+			ExpressionToHqlTranslationResults query = QueryModelVisitor.GenerateHqlQuery(expression.QueryModel, _parameters, false, null);
 			return query.Statement;
 		}