Initializing variable with itself: how come it is not a compile-time error?

I am a bit baffled that I managed to accidentally write code equivalent to this one

int a=a; // there is not a declared before this line

and the compiler happily compiled it - both gcc and clang, which are very standard-conforming and have good diagnostics. (With `-Wall`, gcc 4.8 warns about uninitialized variable; clang does not).

I thought the RHS of the assignment will be evaluated prior do LHS, hence causing `a` to be undefined on the RHS. Can I have some simple clarification about why is this syntactically legal?

It will be a compile-time error if you tell GCC to make it so:

gcc -Winit-self -Werror

Note that sadly this diagnostic is not enabled by most of the usual suspects like -Wall.

The scope of a name starts right after its complete declaration. Thus, `a` is already in scope at the time of its initialization.

Stroustrup has the very same example as you noted to demonstrate scoping rules.

See: Stroustrup "The C++ Programming Language, 4th ed.", p.158.

Edit:
Oops, didn't notice question was tagged with "C", but still, I think it works for C quite as well