Add support for MemberInit expression in GroupBySelectClauseRewriter (nhibernate#2221)

Author: maca88

src/NHibernate.Test/Async/Linq/ByMethod/GroupByTests.cs

@@ -910,6 +910,48 @@ public async Task GroupByOrderByKeySelectToClassAsync()
 				.ToListAsync());
 		}
 
+		[Test]
+		public async Task SelectArrayIndexBeforeGroupByAsync()
+		{
+			var result = db.Orders
+							.SelectMany(o => o.OrderLines.Select(c => c.Id).DefaultIfEmpty().Select(c => new object[] {c, o}))
+							.GroupBy(g => g[0], g => (Order) g[1])
+							.Select(g => new[] {g.Key, g.Count(), g.Max(x => x.OrderDate)});
+
+			Assert.True(await (result.AnyAsync()));
+		}
+
+		[Test]
+		public async Task SelectMemberInitBeforeGroupByAsync()
+		{
+			var result = await (db.Orders
+							.Select(o => new OrderGroup {OrderId = o.OrderId, OrderDate = o.OrderDate})
+							.GroupBy(o => o.OrderId)
+							.Select(g => new OrderGroup {OrderId = g.Key, OrderDate = g.Max(o => o.OrderDate)})
+							.ToListAsync());
+
+			Assert.True(result.Any());
+		}
+
+		[Test]
+		public async Task SelectNewBeforeGroupByAsync()
+		{
+			var result = await (db.Orders
+							.Select(o => new {o.OrderId, o.OrderDate})
+							.GroupBy(o => o.OrderId)
+							.Select(g => new {OrderId = g.Key, OrderDate = g.Max(o => o.OrderDate)})
+							.ToListAsync());
+
+			Assert.True(result.Any());
+		}
+
+		private class OrderGroup
+		{
+			public int OrderId { get; set; }
+
+			public DateTime? OrderDate { get; set; }
+		}
+
 		private class GroupInfo
 		{
 			public object Key { get; set; }

src/NHibernate.Test/Linq/ByMethod/GroupByTests.cs

@@ -912,6 +912,48 @@ public void FetchBeforeGroupBy()
 			Assert.True(result.Any());
 		}
 
+		[Test]
+		public void SelectArrayIndexBeforeGroupBy()
+		{
+			var result = db.Orders
+							.SelectMany(o => o.OrderLines.Select(c => c.Id).DefaultIfEmpty().Select(c => new object[] {c, o}))
+							.GroupBy(g => g[0], g => (Order) g[1])
+							.Select(g => new[] {g.Key, g.Count(), g.Max(x => x.OrderDate)});
+
+			Assert.True(result.Any());
+		}
+
+		[Test]
+		public void SelectMemberInitBeforeGroupBy()
+		{
+			var result = db.Orders
+							.Select(o => new OrderGroup {OrderId = o.OrderId, OrderDate = o.OrderDate})
+							.GroupBy(o => o.OrderId)
+							.Select(g => new OrderGroup {OrderId = g.Key, OrderDate = g.Max(o => o.OrderDate)})
+							.ToList();
+
+			Assert.True(result.Any());
+		}
+
+		[Test]
+		public void SelectNewBeforeGroupBy()
+		{
+			var result = db.Orders
+							.Select(o => new {o.OrderId, o.OrderDate})
+							.GroupBy(o => o.OrderId)
+							.Select(g => new {OrderId = g.Key, OrderDate = g.Max(o => o.OrderDate)})
+							.ToList();
+
+			Assert.True(result.Any());
+		}
+
+		private class OrderGroup
+		{
+			public int OrderId { get; set; }
+
+			public DateTime? OrderDate { get; set; }
+		}
+
 		private class GroupInfo
 		{
 			public object Key { get; set; }

src/NHibernate/Linq/GroupBy/GroupBySelectClauseRewriter.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using NHibernate.Linq.Expressions;
@@ -14,6 +15,13 @@ namespace NHibernate.Linq.GroupBy
 	//This should be renamed. It handles entire querymodels, not just select clauses
 	internal class GroupBySelectClauseRewriter : RelinqExpressionVisitor
 	{
+		private readonly static HashSet<ExpressionType> _validElementSelectorTypes = new HashSet<ExpressionType>
+		{
+			ExpressionType.ArrayIndex,
+			ExpressionType.New,
+			ExpressionType.MemberInit
+		};
+
 		public static Expression ReWrite(Expression expression, GroupResultOperator groupBy, QueryModel model)
 		{
 			var visitor = new GroupBySelectClauseRewriter(groupBy, model);
@@ -67,8 +75,8 @@ protected override Expression VisitMember(MemberExpression expression)
 				return base.VisitMember(expression);
 			}
 
-			if ((elementSelector is NewExpression || elementSelector.NodeType == ExpressionType.Convert)
-				&& elementSelector.Type == expression.Expression.Type)
+			if (_validElementSelectorTypes.Contains(UnwrapUnary(elementSelector).NodeType) &&
+				elementSelector.Type == expression.Expression.Type)
 			{
 				//TODO: probably we should check this with a visitor
 				return Expression.MakeMemberAccess(elementSelector, expression.Member);
@@ -156,5 +164,12 @@ expression.QueryModel.SelectClause.Selector is NhCountExpression countExpression
 			// valid assumption.  Should probably be passed a list of aggregating subqueries that we are flattening so that we can check...
 			return ReWrite(expression.QueryModel.SelectClause.Selector, _groupBy, _model);
 		}
+
+		private static Expression UnwrapUnary(Expression expression)
+		{
+			return expression is UnaryExpression unaryExpression
+				? unaryExpression.Operand
+				: expression;
+		}
 	}
 }