https://issues.dlang.org/show_bug.cgi?id=19394
Walter Bright <bugzi...@digitalmars.com> changed: What |Removed |Added ---------------------------------------------------------------------------- Status|NEW |RESOLVED CC| |bugzi...@digitalmars.com Resolution|--- |INVALID --- Comment #1 from Walter Bright <bugzi...@digitalmars.com> --- Non-named enums are manifest constants, no anonymous type is created. To give a name to a group of enums does indeed change its nature. A more detailed explanation of what is happening: int f(short s) { return 1; } int f(int i) { return 2; } enum : int { a = 0 } enum A : int { a = 0 } pragma (msg, f(a)); // calls f(int) pragma (msg, f(A.a)); // calls f(short) I.e. bool is consistent with how other integral types work. Here's how it works: f(a): `a` is a manifest constant of type `int`, and `int` is an exact match for f(int), and f(short) requires an implicit conversion. The exact match of f(int) is better. f(A.a): `a` is an enum of type `A`. `A` gets implicitly converted to `int`. The `int` then gets exact match to f(int), and an implicit match to f(short). The sequence of conversions is folded into one according to: <implicit conversion> <exact> => <implicit conversion> <implicit conversion> <implicit conversion> => <implicit conversion> Both f(int) and f(short) match, because implicit conversions rank the same. To disambiguate, f(short) is pitted against f(int) using partial ordering rules, which are: Can a short be used to call f(int)? Yes. Can an int be used to call f(short)? No. So f(short) is selected, because the "Most Specialized" function is selected when there is an ambiguous match. Note: the "most specialized" partial ordering rules are independent of the arguments being passed. The behavior is as intended. Marked as invalid. --