The method wasn't used by re-linq and didn't really fit the API. It was just a shortcut for ReflectionUtility.GetItemTypeOfIEnumerable.
Previously, ResultOperatorBase provided a default implementation of TransformExpressions which didn't do anything. Because of this, it was easy to forget to implement that method when writing a result operator holding an expression.
Therefore, the method was made abstract instead, this will force subclasses to make a conscious decision about whether to implement the method or not.
There are two versions of the aggregate operation: one simply aggregates the values into a compond value (ints.Aggregate ((total, i) => total + i), the other takes a seed and accumulates the values with the seed (ints.Aggregate ("Result: ", (totalString, i) => totalString + " " + i). The latter variant can also take a result selector that transforms the final result before it is returned.
These two variants are expressed by re-linq by two result operators: AggregateResultOperator and AggregateFromSeedResultOperator. Both hold the aggregating function as a resolved LambdaExpression with exactly one parameter: the value accumulated so far. The input data is represented by a query source reference: (from i in ints select i).Aggregate (total => total + [i]). The resolved form makes the expression easier to analyze and the result operators consistent with the other clauses and result operators. The unresolved lambda can be retrieved by reverse-resolving the expression using ReverseResolvingExpressionTreeVisitor.