[Clang] Incorrect Diagnostic Message for Ambiguous Overloaded Operator in Clang

[wangbo15]

Given the following code:

#include<iostream>
struct operand
{
  int x;
  operator int (){return x;};
  operator bool() {return true;};
  operator char() {return 'c';};
};

bool bar (operand i, operand j)
{
  bool tst = (i == j);
  return tst;
}

int main(){
    operand o1{1}, o2{0};
    std::cout<<bar(o1, o2);
}

Clang rejects it with the diagnostic, which dose not make sense, because there is no float in the source code:

<source>:12:17: error: use of overloaded operator '==' is ambiguous (with operand types 'operand' and 'operand')
   12 |   bool tst = (i == j);
      |               ~ ^  ~
<source>:12:17: note: because of ambiguity in conversion of 'operand' to 'float'
<source>:5:3: note: candidate function
    5 |   operator int (){return x;};
      |   ^
<source>:6:3: note: candidate function
    6 |   operator bool() {return true;};
      |   ^
<source>:7:3: note: candidate function
    7 |   operator char() {return 'c';};
      |   ^
<source>:12:17: note: because of ambiguity in conversion of 'operand' to 'float'
   12 |   bool tst = (i == j);
      |                 ^
<source>:5:3: note: candidate function
    5 |   operator int (){return x;};
      |   ^
<source>:6:3: note: candidate function
    6 |   operator bool() {return true;};
      |   ^
<source>:7:3: note: candidate function
    7 |   operator char() {return 'c';};
      |   ^
<source>:12:17: note: built-in candidate operator==(float, float)
   12 |   bool tst = (i == j);

Moreover, MSVC's output seems correct:

example.cpp
<source>(12): error C2593: 'operator ==' is ambiguous
<source>(12): note: could be 'built-in C++ operator==(int, int)'
<source>(12): note: or       'built-in C++ operator==(int, bool)'
<source>(12): note: or       'built-in C++ operator==(int, char)'
<source>(12): note: or       'built-in C++ operator==(bool, int)'
<source>(12): note: or       'built-in C++ operator==(bool, bool)'
<source>(12): note: or       'built-in C++ operator==(bool, char)'
<source>(12): note: or       'built-in C++ operator==(char, int)'
<source>(12): note: or       'built-in C++ operator==(char, bool)'
<source>(12): note: or       'built-in C++ operator==(char, char)'
<source>(12): note: while trying to match the argument list '(operand, operand)'
cl : Command line warning D9002 : ignoring unknown option '-std=c++20'
Compiler returned: 2

[keinflue]

The diagnostic seems nonsensical to a user, but makes sense considering the overload resolution rules required by the standard.

Specifically overload resolution is done for == to detect which conversion functions will be used by considering hypothetical overloads for operator==, including among others operator==(L, R) for every pair L/R of promoted integer or floating-point types.

This means that there is an overload operator==(float, float) to consider as the error message indicates. For this overload, in either argument, there is an ambiguity in the choice for the conversion function, because all of them require a second standard conversion sequence of the same rank from integer to floating point type. Therefore the implicit conversion sequence for these arguments is considered the ambiguous conversion sequence.

The ambiguous conversion sequence is always considered neither better or worse than any other user-defined conversion sequence, meaning that it will be ambiguous with every other possible choice of conversion functions for the other operator== overloads. And therefore overload resolution is ambiguous and fails.

This is what the error message states. The operator==(float, float) overload in particular is not important, it could have used many others with the same result. But a single ambiguous conversion sequence is sufficient to make all overloads ambiguous.

See #10981 for a similar issue about the quality of the diagnostic.

See also CWG 260 and CWG 507 regarding this behavior of overload resolution with ambiguous conversion sequences on operators.

MSVC's error message is incorrect, because there are no (hypothetical) overloads of operator== for the non-promoted integer types, i.e. all but operator==(int, int) in that list should not exist and other overloads like those for higher rank integer types and floating point types are missing.