Enums, typedefs and lowest common denominators

[Stewart Gordon]

http://www.digitalmars.com/d/type.html
"# If one operand is a typedef and the other is the base type of that 
typedef, the result is the base type.
# If the two operands are different typedefs but of the same base type, 
then the result is that base type."

Something's puzzling here.  I first noticed a problem when the SDWF 
example program MDI Edit stopped compiling.  For the record, the error is:
----------
mdiedit.d(284): function smjg.libs.sdwf.windowbase.WindowBase.style () 
does not match parameter types (uint)
mdiedit.d(284): Error: cannot implicitly convert expression 
(((cast(WindowBase)(this.editBox)).style)() | cast(ES)cast(WS)256u) of 
type uint to WS
----------

This appears to be due to promotion rules that have been in place for a 
while, but the problem with this code has only just manifested in the 
light of the fix to bug 349.

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

Anyway, back to the point.  It would appear that by "base type" the spec 
means the built-in (or class or struct or union) type from which the 
typedef is ultimately derived.

This spec doesn't mention anything about enums, but the compiler seems 
to be treating enums and typedefs as a single entity in this respect. 
For example:
----------
import std.stdio;

typedef uint EnumBase;

enum Enum1 : EnumBase { Value1, Value2 }
enum Enum2 : EnumBase { Value3, Value4 }

void test(EnumBase e) {
     writefln("EnumBase: %d", e);
}

void test(uint e) {
     writefln("uint: %d", e);
}

void main() {
     test(Enum1.Value1 | Enum2.Value4);
}
----------

shows that the enum values are promoted to uint, which is the ultimate 
base type of both enums, as passing through both enums and typedefs.

When I suggested OUAT how typedef arithmetic should work, I intended 
typedefs with a common base type to promote to the lowest common 
denominator, i.e. the most-derived typedef that is a common base to 
both.  It would make sense to apply this logic also to enums, and even 
to chains of typedefs and enums.

But the spec certainly has holes here.  Firstly, it ought to clarify 
what is meant by "base type"; secondly, it needs to mention what happens 
to enums in the same circumstance.

Under the lowest common denominator principle, my code would compile 
without trouble.  But for as long as they are always promoted to the 
_ultimate_ base type if at all, it's hard to make these hierarchical 
enums work properly and keep SDWF user-friendly to this degree.  It's 
nice if people can still use

     editBox.style = editBox.style | ES.NOHIDESEL;

rather than

     editBox.style = cast(WS) (editBox.style | ES.NOHIDESEL);


Comments?

Stewart.

-- 
-----BEGIN GEEK CODE BLOCK-----
Version: 3.1
GCS/M d- s:-@ C++@ a->--- UB@ P+ L E@ W++@ N+++ o K-@ w++@ O? M V? PS- 
PE- Y? PGP- t- 5? X? R b DI? D G e++++ h-- r-- !y
------END GEEK CODE BLOCK------

My e-mail is valid but not my primary mailbox.  Please keep replies on 
the 'group where everyone may benefit.