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

Author: fredericDelaporte

src/NHibernate/Linq/EnumerableHelper.cs

@@ -29,7 +29,7 @@ public static MethodInfo GetMethodDefinition<TSource>(Expression<Action<TSource>
 		public static MethodInfo GetMethod<TSource>(Expression<Action<TSource>> method)
 		{
 			if (method == null)
-				throw new ArgumentNullException("method");
+				throw new ArgumentNullException(nameof(method));
 
 			return ((MethodCallExpression)method.Body).Method;
 		}
@@ -54,11 +54,40 @@ public static MethodInfo GetMethodDefinition(Expression<System.Action> method)
 		public static MethodInfo GetMethod(Expression<System.Action> method)
 		{
 			if (method == null)
-				throw new ArgumentNullException("method");
+				throw new ArgumentNullException(nameof(method));
 
 			return ((MethodCallExpression)method.Body).Method;
 		}
 
+		/// <summary>
+		/// Get the <see cref="MethodInfo"/> for a public overload of a given method if the method does not match
+		/// given parameter types, otherwise directly yield the given method.
+		/// </summary>
+		/// <param name="method">The method for which finding an overload.</param>
+		/// <param name="parameterTypes">The arguments types of the overload to get.</param>
+		/// <returns>The <see cref="MethodInfo"/> of the method.</returns>
+		/// <remarks>Whenever possible, use GetMethod() instead for performance reasons.</remarks>
+		public static MethodInfo GetMethodOverload(MethodInfo method, System.Type[] parameterTypes)
+		{
+			if (method == null)
+				throw new ArgumentNullException(nameof(method));
+			if (parameterTypes == null)
+				throw new ArgumentNullException(nameof(parameterTypes));
+
+			if (ParameterTypesMatch(method.GetParameters(), parameterTypes))
+				return method;
+
+			var overload = method.DeclaringType.GetMethod(method.Name,
+				(method.IsStatic ? BindingFlags.Static : BindingFlags.Instance) | BindingFlags.Public,
+				null, parameterTypes, null);
+
+			if (overload == null)
+				throw new InvalidOperationException(
+					$"No overload found for method '{method.DeclaringType.Name}.{method.Name}' and parameter types '{string.Join(", ", parameterTypes.Select(t => t.Name))}'");
+
+			return overload;
+		}
+
 		/// <summary>
 		/// Gets the field or property to be accessed.
 		/// </summary>
@@ -70,7 +99,7 @@ public static MemberInfo GetProperty<TSource, TResult>(Expression<Func<TSource,
 		{
 			if (property == null)
 			{
-				throw new ArgumentNullException("property");
+				throw new ArgumentNullException(nameof(property));
 			}
 			return ((MemberExpression)property.Body).Member;
 		}
@@ -91,31 +120,8 @@ internal static System.Type GetPropertyOrFieldType(this MemberInfo memberInfo)
 
 			return null;
 		}
-	}
-	
-	[Obsolete("Please use ReflectionHelper 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))
-				.Single();
-		}
-
-		public static MethodInfo GetMethod(string name, System.Type[] parameterTypes, System.Type[] genericTypeParameters)
-		{
-			return typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public)
-				.Where(m => m.Name == name &&
-							m.ContainsGenericParameters &&
-							m.GetGenericArguments().Count() == genericTypeParameters.Length &&
-							ParameterTypesMatch(m.GetParameters(), parameterTypes))
-				.Single()
-				.MakeGenericMethod(genericTypeParameters);
-		}
 
-		private static bool ParameterTypesMatch(ParameterInfo[] parameters, System.Type[] types)
+		internal static bool ParameterTypesMatch(ParameterInfo[] parameters, System.Type[] types)
 		{
 			if (parameters.Length != types.Length)
 			{
@@ -141,4 +147,27 @@ private static bool ParameterTypesMatch(ParameterInfo[] parameters, System.Type[
 			return true;
 		}
 	}
+
+	[Obsolete("Please use ReflectionHelper 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 &&
+							ReflectionHelper.ParameterTypesMatch(m.GetParameters(), parameterTypes))
+				.Single();
+		}
+
+		public static MethodInfo GetMethod(string name, System.Type[] parameterTypes, System.Type[] genericTypeParameters)
+		{
+			return typeof(Enumerable).GetMethods(BindingFlags.Static | BindingFlags.Public)
+				.Where(m => m.Name == name &&
+							m.ContainsGenericParameters &&
+							m.GetGenericArguments().Count() == genericTypeParameters.Length &&
+							ReflectionHelper.ParameterTypesMatch(m.GetParameters(), parameterTypes))
+				.Single()
+				.MakeGenericMethod(genericTypeParameters);
+		}
+	}
 }

src/NHibernate/Linq/ExpressionToHqlTranslationResults.cs

@@ -16,11 +16,18 @@ public class ExpressionToHqlTranslationResults
 		public Delegate PostExecuteTransformer { get; private set; }
 		public List<Action<IQuery, IDictionary<string, Tuple<object, IType>>>> AdditionalCriteria { 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; private set; }
+
 		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 +42,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[]
-			                   	{
-			                   		ReflectionHelper.GetMethodDefinition(() => Queryable.All<object>(null, null)),
-			                   		ReflectionHelper.GetMethodDefinition(() => Enumerable.All<object>(null, null))
-			                   	};
+			{
+				ReflectionHelper.GetMethodDefinition(() => Queryable.All<object>(null, null)),
+				ReflectionCache.EnumerableMethods.AllDefinition
+			};
 		}
 
 		public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)

src/NHibernate/Linq/IntermediateHqlTree.cs

@@ -50,6 +50,12 @@ public HqlTreeNode Root
 			}
 		}
 
+		/// <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; private set; }
 
 		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

@@ -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;
 		}