As there is no answer for a week, I will post my vision. I am far from being an expert at language-laywering, actually I would consider myself a complete novice, but still. The following is based on my reading of standard, as well on my recent question.
So, first of all let's rewrite the code the following way:
struct A {
constexpr operator int() const { return 42; }
};
template <int>
void foo() {}
void test(const A& value) {
foo<value>();
}
int main() {
A a{};
test(a);
}
It exhibits the same behavior (builds with gcc and fails with similar error with clang), but:
- is free from template type deduction at
test(), to make sure the problem has nothing to do with type deduction,
- uses 'mocks' instead of
std members to make sure this is not a problem with their implementation,
- and has an explicit variable
a, not a temporary, to be explained later.
What does happen here? I will quote N4296.
We have a template foo with a non-type parameter.
[14.3.2(temp.arg.nontype)]/1:
A template-argument for a non-type template-parameter shall be a
converted constant expression (5.20) of the type of the
template-parameter.
So template argument, i.e. value, should be a converted constant expression of type int.
[5.20(expr.const)]/4:
A converted constant expression of type T is an expression, implicitly
converted to type T, where the converted expression is a constant
expression and the implicit conversion sequence contains only
- user-defined conversions,
- ... (irrelevant bullets dropped)
and where the reference binding (if any) binds directly.
Our expression (value) can be implicitly converted to type int, and the conversion sequence contains only user-defined conversions. So the two questions remain: whether "the converted expression is a constant expression" and whether "the reference binding (if any) binds directly".
For the first question, the phrase "the converted expression", I think, means the expression as already converted to int, that is something like static_cast<int>(value), not the original expression (value). For that,
[5.20(expr.const)]/2:
A conditional-expression e is a core constant expression unless the
evaluation of e, following the rules of the abstract machine (1.9),
would evaluate one of the following expressions:
- ... (a long list omitted)
Evaluation of our expression, static_cast<int>(value), leads only to evaluation of A::operator int(), which is constexpr, and thus is explicitly allowed. No members of A (if there were any) are evaluated, neither anything else is evaluated.
Therefore, static_cast<int>(value) is a constant expression.
For the second question, about reference binding, it is not clear for me to which process this refers at all. However, anyway we have only one reference in our code (const A& value), and it binds directly to the variable a of main (and this is the reason why I introduced a).
Indeed, direct binding is defined at the end of [8.5.3(dcl.init.ref)]/5:
In all cases except the last (i.e., creating and initializing a
temporary from the initializer expression), the reference is said to
bind directly to the initializer expression.
This "last" case seem to refer to 5.2, and non-direct binding means initialization from a temporary (like const int& i = 42;), not our case when we have a non-temporary a.
UPD: I asked a separate question to check whether my understanding of the standard, presented above, is correct.
So the bottomline is that the code should be valid, and clang is wrong. I suggest you filing a bug to clang bug tracker, with a reference to this question. Or if for whatever reason you will not file a bug, let me know, I will file it.
UPD: filed a bug report
