Issue 7358 - final switch over enum should add throwing default in debug mode

[yebblies]

Add a throwing default case when compiled with asserts on.

http://d.puremagic.com/issues/show_bug.cgi?id=7358

[andralex]

This is good. We must discuss disabling "|" for enums (which I think is terrible) separately.

[alexrp]

@andralex I think disabling that would be very unreasonable; it would make using enums for sort-of-type-safe bit flags annoying.

[andralex]

@alexrp ... and would make using enums for REALLY GOOD CATEGORICAL TYPES awesome.

[donc]

Possibly you could make a case for bitwise operations on enums which have had their size explicitly specified and all members given explicit values (eg, enum Foo : int { A = 1, B = 2 }, the Windows header files use enums in that way), but I don't think there's any case for allowing bitwise operations on enums which haven't explicitly specified a type.

[ghost]

@andralex: and would make porting C/C++ code difficult.

[jmdavis]

| on enums is fine. Having the result be an enum is not, and that is what needs to be changed. Any and all operations which result in an enum should be guaranteed to be a valid enum value. Now, because of casting, it'll still always be possible to get an invalid enum value, so making final switch throw in that case is good, but if casting isn't involved, it should be impossible for operating on enum values to result in a value which is of the enum type and not be a valid enum value.

[ghost]

@jmdavis: It would be great if we could actually define valid operations on enums.

For example if you want to only define | on enums you would define opBinary (and other operators when necessary).

enum Flag
{
    a = 0x01,
    b = 0x02;

    @disable auto opBinary(string op, T)(T rhs) { }
    auto opBinary(string op : "|", T)(T rhs) { return this | rhs; }
}

Which would be similar to:

struct Flag
{
    int flag;

    enum a = 0x01;
    enum b = 0x02;

    @disable auto opBinary(string op, T)(T rhs) { }
    auto opBinary(string op : "|", T)(T rhs) { return Flag(this.flag | rhs.flag); }
}

void main()
{
    Flag f = Flag(Flag.a) | Flag(Flag.b);
    assert(f.flag == (0x01 | 0x02));
}

[yebblies]

Rebased, should be ready.

[denis-sh]

@andralex I think disabling that would be very unreasonable; it would make using enums for sort-of-type-safe bit flags annoying.

Just want to mention that at least one library solution for bit flags is ready: unstd.typecons.flagEnum.