Enumeration representation clause surprise.

Hello,

please consider the following code snippet:

    type ENUM_T is (ONE, TWO);
    for ENUM_T use (ONE => 1, TWO => 2);

    type RECORD_T is record
       A1 : ENUM_T;
       A2 : ENUM_T;
    end record;
    for RECORD_T use record
       A1 at 0 range 0 .. 0; -- (*)
       A2 at 1 range 0 .. 7;
    end record;
    for RECORD_T'Size use 2 * 8;

    FOO : RECORD_T;

I was _very_ surprised to discover that when executing

    FOO.A1 := TWO;
    FOO.A2 := TWO;

the binary content of FOO looks like this:

    00000010 00000001

IOW, for A1 ONE is coded as 0 and TWO as 1, and for A2 ONE is coded as 1 
and TWO as 2.

I checked this with GNAT 3.4.5 and some old DEC Ada compiler, therefore I 
think this behaviour is compiler independent.

Anybody knows why the compiler is allowed to silently ignore my 
representation clause for the enumeration? I would have expected to get an

error at the indicated line, telling me that A1 is too small.

BTW, this was found in a real word application, where code like this was 
used to model a given external interface, and later the enumeration was 
extended by a few values, but the record representation clause was never 
updated.

Is there a way I can protect myself from this very nasty trap?

Best regards,
Markus