Range of enum type values

[Johan Engelen]

Hi all,
   I am wondering about the valid range of values of an enum type. 
I couldn't find anything explicit about this in the language 
specification.

Consider this code:
```
enum Flags
{
     A = 1,
     B = 2,
     C = 4
}

bool rangeCheck(Flags f)
{
     return (f >= Flags.min) && (f <= Flags.max);
}
bool preciseCheck(Flags f)
{
     return (f == Flags.A) || (f == Flags.B) || (f == Flags.C);
}```

Is `rangeCheck` guaranteed to return true? Is `preciseCheck` 
guaranteed to return true?
A variable of type Flags is always initialized to Flags.A.
Integer assignment is not allowed.
So `Flags f` should always have a value of A B or C, right?

No. This code is accepted:
```
Flags getFlags()
{
     return Flags.A | Flags.B; // and so is `^`, `&`, `+`, `*`, ...
}
```

I'd like to have the value range implications of the use of 
operators on enum values explicitly mentioned in the spec.

Current compiler behavior results in an infinite value range. 
(but it's implicit behavior, i.e. not explicitly mentioned in 
spec)

- Currently, are operations resulting in a value larger than the 
underlying integer storage type UB, like for normal signed 
integers?
- Should we limit the range of valid values of the Flags enum 
(C++ defines valid range to be [0..7])?
- Do we want to limit operations allowed on enum types? Or change 
the result type? (e.g. the type of `Flags + Flags` is `int` 
instead of `Flags`.

cheers,
   Johan