Can LINQ be slightly more optimal? Would it be a huge burden for the compiler?

[voroninp]

This:

var x = from i in Enumerable.Range(0, 10) select i;

turns into:

IEnumerable<int> q = Enumerable.Range(0, 10).Select((int i) => i);

yet it could be just:

IEnumerable<int> q = Enumerable.Range(0, 10);

This:

var q = from i in Enumerable.Range(0, 10)
	let j = i + 1
	where j % 2 == 0
	select i;

turns into:

IEnumerable<int> q = Enumerable.Range(0, 10).Select((int i) => new
{
	i = i,
	j = i + 1
}).Where(<>h__TransparentIdentifier0 => <>h__TransparentIdentifier0.j % 2 == 0)
	.Select(<>h__TransparentIdentifier0 => <>h__TransparentIdentifier0.i);

While if it were:

IEnumerable<int> q = Enumerable.Range(0, 10).Where(i => (i+1) % 2 == 0))

there would be fewer allocations.

This:

var q = from i in Enumerable.Range(0, 10)
	let j = i + 1
	select j;

becomes:

IEnumerable<int> q = Enumerable.Range(0, 10).Select((int i) => new
{
	i = i,
	j = i + 1
}).Select(<>h__TransparentIdentifier0 => <>h__TransparentIdentifier0.j);

and could be:

IEnumerable<int> q = Enumerable.Range(0, 10).Select(i => i+1);

When let is used exclusively in the next expression, the inlining should work, shouldn't it?

And one more:

var q = from i in Enumerable.Range(0, 10)
	let j = i + 1
	select i;

is compiled as:

IEnumerable<int> q = Enumerable.Range(0, 10).Select((int i) => new
{
	i = i,
	j = i + 1
}).Select(<>h__TransparentIdentifier0 => <>h__TransparentIdentifier0.i);

Why not:

IEnumerable<int> q = Enumerable.Range(0, 10).Select(i =>
{
    var j = i+1; // + can have a side effect for some other type.
    return i;
});

In most cases I prefer extension methods to LINQ, but for complex queries LINQ can be better for readability,
and having let variables also helps to improve readability by splitting large expressions into simple ones.
But I don't want to pay performance penalty for choosing LINQ.

Hence, I'd like to understand, how difficult it is to make such optimizations.

[huoyaoyuan]

See dotnet/csharplang#2482