gcc vs clang: noexcept parsed in unused template specialization when static casting

user_7014926 0
Viewed 214

I am trying to static cast a function pointer to a specific function overload, but it seems that clang still parses the noexcept statement of the (unused) template specialization and thus generates a compiler error. GCC doesn't seem to care about the noexcept if the corresponding function overload is unused.

template<typename T>
void fun( T ) noexcept( T(1) ){}

void fun(int) {}

void fun(int*) {}

int main () {
    int a;
    fun(&a); //calling works fine
    fun(a);
    static_cast<void(*)(int*)>(&fun); // static casting doesn't
}

https://godbolt.org/z/ixpl3f

Which compiler is wrong here?
Does the standard specify what exactly should be compiled when casting function pointers to specific overloads?

EDIT: After Maxim's comment, i put back the second noexcept into the example and it compiled on both gcc and clang.

So here is another example, where it actually fails with noexcept(noexcept(...))

https://godbolt.org/z/NMW99C

function-pointers static-cast templates c++
3 Answers

When it comes to taking the address of a function template, as your static cast does, the standard has this relevant paragraph:

[over.over] Address of overloaded function (emphasis mine)

2 If the name is a function template, template argument deduction is done ([temp.deduct.funcaddr]), and if the argument deduction succeeds, the resulting template argument list is used to generate a single function template specialization, which is added to the set of overloaded functions considered.

Template argument deduction (which doesn't take the exception specification into account), succeed. So then the entire function is instantiated. Only after this instantiation will the compiler check if there is a better non-template match:

4 If more than one function is selected, any function template specializations in the set are eliminated if the set also contains a function that is not a function template specialization

This is unlike the case of a function call, where overload resolution will discard the function specialization early based on the existence of a non-template overload. In this case, the standard requires the existence of the function lvalue before being certain that it's really needed. I'm not sure if it can be considered a wording defect, or there is a higher cause, but it does seem un-intuitive.

So the conclusion is that Clang is not wrong, but GCC is way more intuitive in its behavior.

user_8176430

[over.over] ¶1 A function with type F is selected for the function type FT of the target type required in the context if F (after possibly applying the function pointer conversion ([conv.fctptr])) is identical to FT.

[conv.fctptr] A prvalue of type "pointer to noexcept function" can be converted to a prvalue of type "pointer to function".

This implies that, after template argument deduction has been done ([over.over] ¶2) to determine the template function specialization to be added to the overload set, the types of the template function specialization and the non-template function must both be compared to the target type, to decide which of them should be "selected".

The tie-breaker for preferring the non-template function (¶4) only comes into effect if the types of both of the functions match the target type (i.e. if more than one function is selected).

void(*)(int*) and void(*)(int*)noexcept are two different types. The cast expression requires the instantiation of the exception specifications of both overloads, in order to determine which of them match the target type of the cast (i.e. which of them should be selected) whereas the call expression only requires the instantiation of the exception specification of the overload selected by overload resolution.

I believe Clang is correct to require the instantiation of the exception specification of the function template specialization. It's plausible that GCC first checks whether the non-template function's type is a match, and if it is, then it has no need to check the type of the function template specialization, knowing that even if it matches, the tie-breaker will eliminate it anyway. It's possible that this is also conformant, and the standard is being ambiguous here.

user_16392560

A bit off-topic, but worth mentioning that if you'd like to say that function template fun is noexcept only if T(1) doesn't throw, then 

template<typename T>
void fun( T ) noexcept( T(1) ){}

Should be 

template<typename T>
void fun( T ) noexcept(noexcept(T(1))){}

The first noexcept is a specifier, the second one is an operator.

user_4120800
Related