foreach and element type inference

[Nicolas F. via Digitalmars-d]

Today I stumbled upon something somewhat confusing to me with 
regards to type inference and foreach loops.

As hopefully people are aware, declaring variables works like 
this:

int[] foo = [1, 2, 3, 4];

and declaring them with type inference works like this:

auto foo = [1, 2, 3, 4];

However, if we have a foreach loop, the following is the case:

foreach (int e; foo) { } // Works as expected
foreach (auto e; foo) { } // Does not work, "Error: basic type 
expected, not auto"
foreach (e; foo) { } // Works, type inference!

Somebody on #d told me that this is due to "auto" being 
essentially meaningless other than a keyword for saying "we're 
declaring a variable", and since we're always declaring a 
variable in the case of foreach, it'd be redundant.

Allowing "auto" here, as somebody pointed out, would lead to two 
styles which may be confusing as one might mistake "foreach (e" 
to be different from "foreach (auto e", and even worse, might be 
led to believe that "e" was declared earlier in the former case.

Enforcing "auto" inside foreach declarations would break old code 
for no reason other than adding a redundant keyword to make 
things more obvious to people who don't know the semantic 
workings of "foreach" (i.e. don't realise it's always a 
declaration there).

The third, and in my opinion, most pragmatic approach to clearing 
things up is to improve the compiler error message for this 
special case of somebody trying to use "auto" inside foreach. 
"Error: basic type expected, not auto" was misleading to me, 
since it almost seems like it requires a basic type 
syntactically, which it doesn't. This would also make things 
clearer without actually changing the language spec.

TL;DR: My suggestion is to have the compiler output a specific 
error message should it encounter "auto" inside a foreach 
declaration, pointing out that "auto" is neither needed nor 
allowed in this context to get type inference.

Any thoughts or opinions on this?