Resolve Key and Element selectors with standard re-linq's ReverseResolvingExpressionTreeVisitor in ProcessNonAggregatingGroupBy

Author: hazzik

src/NHibernate/Linq/Visitors/GroupByKeySelectorVisitor.cs

@@ -3,31 +3,34 @@
 using System.Collections.Generic;
 using System.Linq.Expressions;
 using NHibernate.Linq.ResultOperators;
-using Remotion.Linq.Clauses.Expressions;
-using Remotion.Linq.Parsing.ExpressionTreeVisitors;
+using Remotion.Linq.Clauses.ExpressionTreeVisitors;
 
 namespace NHibernate.Linq.Visitors.ResultOperatorProcessors
 {
 	public class ProcessNonAggregatingGroupBy : IResultOperatorProcessor<NonAggregatingGroupBy>
 	{
 		public void Process(NonAggregatingGroupBy resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
 		{
-			var tSource = queryModelVisitor.Model.SelectClause.Selector.Type;
-			var tKey = resultOperator.GroupBy.KeySelector.Type;
-			var tElement = resultOperator.GroupBy.ElementSelector.Type;
+			var selector = queryModelVisitor.Model.SelectClause.Selector;
+			var keySelector = resultOperator.GroupBy.KeySelector;
+			var elementSelector = resultOperator.GroupBy.ElementSelector;
+
+			var sourceType = selector.Type;
+			var keyType = keySelector.Type;
+			var elementType = elementSelector.Type;
 
 			// Stuff in the group by that doesn't map to HQL.  Run it client-side
 			var listParameter = Expression.Parameter(typeof(IEnumerable<object>), "list");
 
-			var keySelectorExpr = CreateSelector(tSource, resultOperator.GroupBy.KeySelector);
+			var keySelectorExpr = ReverseResolvingExpressionTreeVisitor.ReverseResolve(selector, keySelector);
 
-			var elementSelectorExpr = CreateSelector(tSource, resultOperator.GroupBy.ElementSelector);
+			var elementSelectorExpr = ReverseResolvingExpressionTreeVisitor.ReverseResolve(selector, elementSelector);
 
 			var groupByMethod = EnumerableHelper.GetMethod("GroupBy",
 														   new[] { typeof(IEnumerable<>), typeof(Func<,>), typeof(Func<,>) },
-														   new[] { tSource, tKey, tElement });
+														   new[] { sourceType, keyType, elementType });
 
-			var castToItem = EnumerableHelper.GetMethod("Cast", new[] { typeof(IEnumerable) }, new[] { tSource });
+			var castToItem = EnumerableHelper.GetMethod("Cast", new[] { typeof(IEnumerable) }, new[] { sourceType });
 
 			var toList = EnumerableHelper.GetMethod("ToList", new[] { typeof(IEnumerable<>) }, new[] { resultOperator.GroupBy.ItemType });
 
@@ -41,32 +44,5 @@ public void Process(NonAggregatingGroupBy resultOperator, QueryModelVisitor quer
 
 			tree.AddListTransformer(lambdaExpr);
 		}
-
-		private static LambdaExpression CreateSelector(System.Type sourceType, Expression selector)
-		{
-			var parameter = Expression.Parameter(sourceType, "item");
-			
-			var querySource = GetQuerySourceReferenceExpression(selector);
-			
-			Expression selectorBody;
-			if (sourceType != querySource.Type)
-			{
-				//TODO: it looks like some "magic".
-				var member = sourceType.GetMember(((QuerySourceReferenceExpression) selector).ReferencedQuerySource.ItemName)[0];
-
-				selectorBody = Expression.MakeMemberAccess(parameter, member);
-			}
-			else
-			{
-				selectorBody = ReplacingExpressionTreeVisitor.Replace(querySource, parameter, selector);
-			}
-			
-			return Expression.Lambda(selectorBody, parameter);
-		}
-
-		private static Expression GetQuerySourceReferenceExpression(Expression keySelector)
-		{
-			return new GroupByKeySourceFinder().Visit(keySelector);
-		}
 	}
 }

src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessNonAggregatingGroupBy.cs

@@ -1013,7 +1013,6 @@
     <Compile Include="Linq\ExpressionToHqlTranslationResults.cs" />
     <Compile Include="Linq\EnumerableHelper.cs" />
     <Compile Include="Linq\GroupBy\GroupBySelectClauseRewriter.cs" />
-    <Compile Include="Linq\Visitors\GroupByKeySelectorVisitor.cs" />
     <Compile Include="Linq\Visitors\HqlGeneratorExpressionTreeVisitor.cs" />
     <Compile Include="Linq\LinqExtensionMethods.cs" />
     <Compile Include="Linq\ReWriters\MergeAggregatingResultsRewriter.cs" />