Multiple implicit conversion operators

Question

Consider the following C++ code:

struct X {
    operator int();
    operator char();
};

struct Y {
    operator int();
    operator char();
};

void f(bool z) { 
    z ? X() : Y(); 
}

GCC compiles it successfully. Clang gives an error:

error: conditional expression is ambiguous; 'X' and 'Y' can be converted to several common types

MSVC also gives an error:

error C2446: ':': no conversion from 'Y' to 'X'

note: No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called

Which compiler is correct here, and what is the relevant part of the C++ Standard in this case? My guess is [over.match.oper] is applicable, but so far I was not able to figure out the expected behavior from it.

Update: if we change both operator int() to convert to some other type, e.g. operator bool(), then GCC gives an error as well. Maybe there is some special rule about int type?

Answer 1

I think it's stated here, [expr.cond]/6:

(emphasis mine)

Otherwise, the result is a prvalue. If the second and third operands do not have the same type, and either has (possibly cv-qualified) class type, overload resolution is used to determine the conversions (if any) to be applied to the operands ([over.match.oper], [over.built]). If the overload resolution fails, the program is ill-formed. Otherwise, the conversions thus determined are applied, and the converted operands are used in place of the original operands for the remainder of this subclause.

That means, given X and Y, which are two different types, overload solution will try to determine any conversion which could be applied. Overload solution fails because both X and Y could be converted to multiple types. The program is ill-formed; Clang is correct.

Note that overload resolution fails because there're multiple conversions for X and Y then the conversion can't be determined. That means even they might have common type after appropriate conversion is performed, the following code is still ill-formed.

struct X {
    operator int();
};

struct Y {
    operator int();
    operator char();
};

void f(bool z) { 
    z ? X() : Y(); 
}

Error message from clang:

prog.cc:11:7: error: conditional expression is ambiguous; 'X' and 'Y' can be converted to several common types
    z ? X() : Y(); 
      ^ ~~~   ~~~