Query: Incorrect warning about group by client eval

[smitpatel]

Repro code:

using System;
using System.Linq;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;

namespace EFSampleApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            using (var db = new MyContext())
            {
                // Recreate database
                db.Database.EnsureDeleted();
                db.Database.EnsureCreated();

                // Seed database


                db.SaveChanges();
            }

            using (var db = new MyContext())
            {
                // Run queries
                var groupedOrders = db.Order
                    .Where(x => x.CompletedOrderId != null)
                    .Where(x => x.OrderDateDt > DateTime.Now.AddDays(-30))
                    .GroupBy(x => new { x.OrderDateDt })
                    .Select(x => new
                    {
                        Date = x.Key.OrderDateDt,
                        Count = x.Count()
                    })
                    .ToList();

            }

            Console.WriteLine("Program finished.");
        }
    }


    public class MyContext : DbContext
    {
        private static ILoggerFactory LoggerFactory => new LoggerFactory().AddConsole(LogLevel.Trace);

        // Declare DBSets
        public DbSet<Order> Order { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            // Select 1 provider
            optionsBuilder
                .UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=_ModelApp;Trusted_Connection=True;Connect Timeout=5;ConnectRetryCount=0")
                //.UseSqlite("filename=_modelApp.db")
                //.UseInMemoryDatabase(databaseName: "_modelApp")
                .EnableSensitiveDataLogging()
                .UseLoggerFactory(LoggerFactory);
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            // Configure model
        }
    }

    public class Order
    {
        public int Id { get; set; }
        public int? CompletedOrderId { get; set; }
        public DateTime OrderDateDt { get; set; }
    }
}

dbug: Microsoft.EntityFrameworkCore.Query[10104]
      Optimized query model:
      'from IGrouping<<>f__AnonymousType0<DateTime>, Order> x in
          (from Order x in DbSet<Order>
          where [x].CompletedOrderId != null
          where [x].OrderDateDt > DateTime DateTime.Now.AddDays(-30)
          select [x]).GroupBy(new <>f__AnonymousType0`1(OrderDateDt = [x].OrderDateDt), [x])
      select new <>f__AnonymousType1<DateTime, int>(
          [x].Key.OrderDateDt,

              (from Order <generated>_1 in [x]
              select [<generated>_1]).Count()
      )'
warn: Microsoft.EntityFrameworkCore.Query[20500]
      The LINQ expression 'GroupBy(new <>f__AnonymousType0`1(OrderDateDt = [x].OrderDateDt), [x])' could not be translated and will be evaluated locally.
dbug: Microsoft.EntityFrameworkCore.Query[10107]
      (QueryContext queryContext) => IEnumerable<<>f__AnonymousType1<DateTime, int>> _InterceptExceptions(
          source: IEnumerable<<>f__AnonymousType1<DateTime, int>> _ShapedQuery(
              queryContext: queryContext,
              shaperCommandContext: SelectExpression:
                  SELECT [x].[OrderDateDt], COUNT(*)
                  FROM [Order] AS [x]
                  WHERE [x].[CompletedOrderId] IS NOT NULL AND ([x].[OrderDateDt] > DATEADD(day, -30E0, GETDATE()))
                  GROUP BY [x].[OrderDateDt],
              shaper: TypedProjectionShaper<ValueBufferShaper, ValueBuffer, <>f__AnonymousType1<DateTime, int>>),
          contextType: EFSampleApp.MyContext,
          logger: DiagnosticsLogger<Query>,
          queryContext: queryContext)