Fix calling Sum without any arguments

src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs

@@ -1440,7 +1440,7 @@
                 }
                 else
                 {
                     if (!TryGetMemberName(expr, out propName)) // TODO : investigate this
                     {
                         if (expr is MethodCallExpression methodCallExpression
                             && methodCallExpression.Arguments.Count == 1
@@ -1496,7 +1496,7 @@
 
         if (newType != null)
         {
             return Expression.NewArrayInit(newType, expressions.Select(expression => _parsingConfig.ExpressionPromoter.Promote(expression, newType, true, true)));
         }
 
         return Expression.NewArrayInit(expressions.All(expression => expression.Type == expressions[0].Type) ? expressions[0].Type : typeof(object), expressions);
@@ -1564,7 +1564,7 @@
                     else
                     {
                         Type propertyType = constructorParameters[i].ParameterType;
                         string cParameterName = constructorParameters[i].Name;
                         var propertyAndIndex = properties.Select((p, index) => new { p, index })
                             .First(p => p.p.Name == cParameterName && (p.p.Type == propertyType || p.p.Type == Nullable.GetUnderlyingType(propertyType)));
                         // Promote from Type to Nullable Type if needed
@@ -1572,7 +1572,7 @@
                     }
                 }
 
                 return Expression.New(ctor, expressionsPromoted, (IEnumerable<MemberInfo>)propertyInfos);
             }
         }
 
@@ -1586,7 +1586,7 @@
                 .Select((t, i) => _parsingConfig.ExpressionPromoter.Promote(expressions[i], t.ParameterType, true, true))
                 .ToArray();
 
             return Expression.New(exactConstructor, expressionsPromoted);
         }
 
         // Option 2. Call the default (empty) constructor and set the members
@@ -2113,18 +2113,19 @@
         }
 
         // #794 - Check if the method is an aggregate (Average or Sum) method and try to update the arguments to match the method arguments
-        _methodFinder.CheckAggregateMethodAndTryUpdateArgsToMatchMethodArgs(methodName, ref args);
+        var isAggregateMethod = _methodFinder.CheckAggregateMethodAndTryUpdateArgsToMatchMethodArgs(methodName, ref args);
 
         var callType = typeof(Enumerable);
         if (TypeHelper.TryFindGenericType(typeof(IQueryable<>), type, out _) && _methodFinder.ContainsMethod(typeof(Queryable), methodName))
         {
             callType = typeof(Queryable);
         }
 
-        // #633 - For Average without any arguments, try to find the non-generic Average method on the callType for the supplied parameter type.
-        if (methodName == nameof(Enumerable.Average) && args.Length == 0 && _methodFinder.TryFindAverageMethod(callType, theType, out var averageMethod))
+        // #633 / #856
+        // For Average/Sum without any arguments, try to find the non-generic Average/Sum method on the callType for the supplied parameter type.
+        if (isAggregateMethod && args.Length == 0 && _methodFinder.TryFindAggregateMethod(callType, methodName, theType, out var aggregateMethod))
         {
-            expression = Expression.Call(null, averageMethod, instance);
+            expression = Expression.Call(null, aggregateMethod, instance);
             return true;
         }
 

src/System.Linq.Dynamic.Core/Parser/SupportedMethods/MethodFinder.cs

@@ -45,25 +45,28 @@ public MethodFinder(ParsingConfig parsingConfig, IExpressionHelper expressionHel
         _expressionHelper = Check.NotNull(expressionHelper);
     }
 
-    public bool TryFindAverageMethod(Type callType, Type parameterType, [NotNullWhen(true)] out MethodInfo? averageMethod)
+    public bool TryFindAggregateMethod(Type callType, string methodName, Type parameterType, [NotNullWhen(true)] out MethodInfo? aggregateMethod)
     {
-        averageMethod = callType
+        aggregateMethod = callType
             .GetMethods()
-            .Where(m => m is { Name: nameof(Enumerable.Average), IsGenericMethodDefinition: false })
+            .Where(m => m.Name == methodName && !m.IsGenericMethodDefinition)
             .SelectMany(m => m.GetParameters(), (m, p) => new { Method = m, Parameter = p })
             .Where(x => x.Parameter.ParameterType == parameterType)
             .Select(x => x.Method)
             .FirstOrDefault();
 
-        return averageMethod != null;
+        return aggregateMethod != null;
     }
 
-    public void CheckAggregateMethodAndTryUpdateArgsToMatchMethodArgs(string methodName, ref Expression[] args)
+    public bool CheckAggregateMethodAndTryUpdateArgsToMatchMethodArgs(string methodName, ref Expression[] args)
     {
         if (methodName is nameof(IAggregateSignatures.Average) or nameof(IAggregateSignatures.Sum))
         {
             ContainsMethod(typeof(IAggregateSignatures), methodName, false, null, ref args);
+            return true;
         }
+
+        return false;
     }
 
     public bool ContainsMethod(Type type, string methodName, bool staticAccess = true)

test/System.Linq.Dynamic.Core.Tests/QueryableTests.GroupBy.cs

@@ -275,4 +275,68 @@ public void GroupBy_Dynamic_SelectWhereAverageWithSelector()
         // Assert
         resultDynamic.Should().BeEquivalentTo(result);
     }
+
+    [Fact]
+    public void GroupBy_Dynamic_SelectWhereSum()
+    {
+        // Arrange
+        var q = new[]
+            {
+                new DataSetA
+                {
+                    I = 5
+                },
+                new DataSetA
+                {
+                    I = 7
+                }
+            }
+            .AsQueryable();
+
+        // Act
+        var result = q
+            .GroupBy(x => x.Time)
+            .Select(x => new { q = x.Select(d => d.I).Where(d => d != null).Sum() })
+            .ToArray();
+
+        var resultDynamic = q
+            .GroupBy("Time")
+            .Select("new (Select(I).Where(it != null).Sum() as q)")
+            .ToDynamicArray();
+
+        // Assert
+        resultDynamic.Should().BeEquivalentTo(result);
+    }
+
+    [Fact]
+    public void GroupBy_Dynamic_SelectWhereSumWithSelector()
+    {
+        // Arrange
+        var q = new[]
+            {
+                new DataSetA
+                {
+                    I = 5
+                },
+                new DataSetA
+                {
+                    I = 7
+                }
+            }
+            .AsQueryable();
+
+        // Act
+        var result = q
+            .GroupBy(x => x.Time)
+            .Select(x => new { q = x.Select(d => d).Sum(y => y.I) })
+            .ToArray();
+
+        var resultDynamic = q
+            .GroupBy("Time")
+            .Select("new (Select(it).Sum(I) as q)")
+            .ToDynamicArray();
+
+        // Assert
+        resultDynamic.Should().BeEquivalentTo(result);
+    }
 }