Keep conversions around a grouping key on the server

- A projection lifted out of a grouping ran a conversion around g.Key in its client selector, replacing the database's CAST
  semantics with .NET's: (decimal)g.Key over a double key no longer rounded to the mapped scale, and (int)g.Key over a long
  key wrapped around instead of failing on overflow.
- Only conversions which can't change the value - to or from the nullable form, boxing, and reference conversions - are now
  applied on the client. Any other conversion makes the projection keep its non-lifted translation, which casts on the server.
- Add tests for a key conversion which changes the value and one which doesn't.

Fixes #39367

Author: Ben O'Donovan

src/EFCore.Relational/Query/RelationalQueryableMethodTranslatingExpressionVisitor.cs

@@ -1658,7 +1658,14 @@ public Expression Rewrite(Expression projection, ParameterExpression groupingPar
                 case NewArrayExpression:
                 case ConstantExpression:
                 case ParameterExpression:
-                case UnaryExpression { NodeType: ExpressionType.Convert or ExpressionType.ConvertChecked }:
+                    return base.Visit(expression);
+
+                // A conversion is computed too, unless it leaves the value as it is: (decimal)g.Key over a double key is a CAST on the
+                // server, which rounds to the mapped scale, and (int)g.Key over a long key is a CAST which fails on overflow rather than
+                // wrapping around. Only wrapping a value in its nullable form (or unwrapping it), boxing it and casting a reference
+                // up its hierarchy are the same in either place.
+                case UnaryExpression { NodeType: ExpressionType.Convert or ExpressionType.ConvertChecked } convert
+                    when IsValuePreservingConversion(convert):
                     return base.Visit(expression);
 
                 default:
@@ -1667,6 +1674,11 @@ public Expression Rewrite(Expression projection, ParameterExpression groupingPar
             }
         }
 
+        private static bool IsValuePreservingConversion(UnaryExpression convert)
+            => convert.Method is null
+                && (convert.Type.UnwrapNullableType() == convert.Operand.Type.UnwrapNullableType()
+                    || (!convert.Type.IsValueType && convert.Type.IsAssignableFrom(convert.Operand.Type)));
+
         private bool TryMatchElements(
             Expression expression,
             out LambdaExpression? elementSelector,

test/EFCore.Specification.Tests/Query/NorthwindGroupByQueryTestBase.cs

@@ -3172,6 +3172,32 @@ public virtual Task GroupBy_selecting_grouping_element_list_with_translated_key(
                 AssertCollection(e.Orders, a.Orders);
             });
 
+    [Theory, MemberData(nameof(IsAsyncData))]
+    public virtual Task GroupBy_selecting_grouping_element_list_with_converted_key(bool async)
+        => AssertQuery(
+            async,
+            ss => ss.Set<OrderDetail>().GroupBy(od => od.Quantity)
+                .Select(g => new { Key = (int)g.Key, Orders = g.Select(od => od.OrderID).ToList() }),
+            elementSorter: e => e.Key,
+            elementAsserter: (e, a) =>
+            {
+                Assert.Equal(e.Key, a.Key);
+                AssertCollection(e.Orders, a.Orders);
+            });
+
+    [Theory, MemberData(nameof(IsAsyncData))]
+    public virtual Task GroupBy_selecting_grouping_element_list_with_nullable_converted_key(bool async)
+        => AssertQuery(
+            async,
+            ss => ss.Set<Employee>().GroupBy(e => e.EmployeeID)
+                .Select(g => new { Key = (uint?)g.Key, Employees = g.Select(e => e.EmployeeID).ToList() }),
+            elementSorter: e => e.Key,
+            elementAsserter: (e, a) =>
+            {
+                Assert.Equal(e.Key, a.Key);
+                AssertCollection(e.Employees, a.Employees);
+            });
+
     [Theory, MemberData(nameof(IsAsyncData))]
     public virtual Task Select_GroupBy_SelectMany(bool async)
         // Entity equality. Issue #15938.

test/EFCore.SqlServer.FunctionalTests/Query/NorthwindGroupByQuerySqlServerTest.cs

@@ -4286,6 +4286,35 @@ ORDER BY [c1].[Region]
 """);
     }
 
+    public override async Task GroupBy_selecting_grouping_element_list_with_converted_key(bool async)
+    {
+        await base.GroupBy_selecting_grouping_element_list_with_converted_key(async);
+
+        AssertSql(
+            """
+SELECT [o1].[c], [o1].[Quantity], [o0].[OrderID], [o0].[ProductID]
+FROM (
+    SELECT CAST([o].[Quantity] AS int) AS [c], [o].[Quantity]
+    FROM [Order Details] AS [o]
+    GROUP BY [o].[Quantity]
+) AS [o1]
+LEFT JOIN [Order Details] AS [o0] ON [o1].[Quantity] = [o0].[Quantity]
+ORDER BY [o1].[Quantity], [o0].[OrderID]
+""");
+    }
+
+    public override async Task GroupBy_selecting_grouping_element_list_with_nullable_converted_key(bool async)
+    {
+        await base.GroupBy_selecting_grouping_element_list_with_nullable_converted_key(async);
+
+        AssertSql(
+            """
+SELECT [e].[EmployeeID], DENSE_RANK() OVER(ORDER BY [e].[EmployeeID])
+FROM [Employees] AS [e]
+ORDER BY [e].[EmployeeID]
+""");
+    }
+
     public override async Task GroupBy_selecting_grouping_element_list(bool async)
     {
         await base.GroupBy_selecting_grouping_element_list(async);