Bug 19394 – Inconsistent overload resolution with named and non-named enums

--- import std.stdio; void foo(bool b) { writefln("bool %s", b); } void foo(int b) { writefln("int %s", b); } enum : int { a = 0 } enum A : int { a = 0 } void main() { foo(a); foo(A.a); } --- Hoped-for result: int 0 int 0 Expected result after reading DIP1015 and its rejection: bool false bool false Actual result: int 0 bool false To give name to a thing, it seems, is to change its very nature.

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.