[Issue 19394] Inconsistent overload resolution with named and non-named enums

d-bugmail at puremagic.com d-bugmail at puremagic.com
Mon Nov 12 22:12:16 UTC 2018


https://issues.dlang.org/show_bug.cgi?id=19394

Walter Bright <bugzilla at digitalmars.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |RESOLVED
                 CC|                            |bugzilla at digitalmars.com
         Resolution|---                         |INVALID

--- Comment #1 from Walter Bright <bugzilla at 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.

--


More information about the Digitalmars-d-bugs mailing list