I agree the wording is unclear. You should file a CWG issue, if there is not already one.

On Wed, Dec 30, 2020 at 9:42 PM jim x via Std-Discussion <std-discussion@lists.isocpp.org> wrote:
About the implicit conversion sequence for the parameter of type `std::initializer_­list<X>`, the relevant rule is worded by:  
>Otherwise, if the parameter type is std::initializer_­list<X> and all the elements of the initializer list can be implicitly converted to X, the implicit conversion sequence is the worst conversion necessary to convert an element of the list to X, or if the initializer list has no elements, the identity conversion.   

So, consider this example: 
````
#include <initializer_list>
struct A{
    operator short(){
        return 0;
    }
};
struct B{
    operator bool(){
        return 0;
    }
};
void fun(std::initializer_list<int>){}
void fun(std::initializer_list<bool>){}
int main(){
    fun({A{},B{}});
}
````
For the parameter type `std::initializer_list<int>`, regardless of the conversion function of `A` or `B`, they all have the user-defined conversion with the second standard conversion sequence an integral promotion. So, which is the worst conversion?  

For the parameter type `std::initializer_list<bool>`, from `A` to `bool`, the conversion sequence comprises a user-defined conversion with the second standard conversion an integral conversion.  Rather, from `B` to `bool`, a user-defined conversion with the second standard conversion a identity conversion. Hence, the worst conversion for `std::initializer_list<bool>` is that of from `A` to `bool`.   

So, the key point falls at which conversion function is the worst conversion for `std::initializer_list<int>`? If it is `A::operator int`, then the following rule will apply to determine the best overload:  
>User-defined conversion sequence U1 is a better conversion sequence than another user-defined conversion sequence U2 if they contain the same user-defined conversion function or constructor or they initialize the same class in an aggregate initialization and in either case the second standard conversion sequence of U1 is better than the second standard conversion sequence of U2.  

Otherwise, if `B::operator bool` is considered as the worst conversion for `std::initializer_list<int>`, then the above rule cannot apply here.  That means calling `fun` will be ambiguous.   

Here is the result of the example, GCC reports an ambiguous error. Instead, the other compilers chose  `void fun(std::initializer_list<int>)` for `fun({A{},B{}})`. It is vague here. I think [over.ics.list#5] should clarify for this example. The rule should be reworded, to point out which is the worst conversion between these conversions when they are indistinguishable, In order to against the other when performing overload resolution.
--
Std-Discussion mailing list
Std-Discussion@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-discussion


--
Brian Bi