非模板函数的尾随要求子句的编译器差异

Question

Consider the following example:

void f() requires true { }
int main() { f(); }

Clang ⁽¹⁾ ( DEMO ) accepts this program, whereas GCC ⁽¹⁾ ( DEMO ) rejects it with the following error:

 error: constraints on a non-templated function

Note that the constraint expression can actually be used in Clang's case, as the following program is rejected by Clang:

void f() requires false { }
int main() { f(); }  //  // error: no matching function for call to 'f'

with Clang noting that that the declared f is not a candidate as the constraints were not satisfied (for it to be a candidate for the f() call; DEMO ).

• Which compiler is correct here, and what is(/are) the relevant standard rule(/s) that govern this?

---

_{(1) GCC HEAD 11.0.0 20210124 and Clang HEAD 12.0.0 (20210124), -std=c++20 .}

Answer 1

_{All standard references below refer, unless noted otherwise, to N4861 (March 2020 post-Prague working draft/C++20 DIS) .}

---

This is a Clang bug, and GCC is correct to reject the program, as per [dcl.decl]/4 (as well as [temp.constr.decl]/1 ) [ emphasis mine]:

The optional requires-clause in an init-declarator or member-declarator shall be present only if the declarator declares a templated function ([dcl.fct]). When present after a declarator, the requires-clause is called the trailing requires-clause . [...]

The same paragraph also contains a (non-normative) example explicitly pointing out the OP's example as ill-formed:

[ Example:

 void f1(int a) requires true; // error: non-templated function template<typename T> auto f2(T a) -> bool requires true; // OK //...

— end example ]

We may note that in an earlier version of the (to become C++20) working draft, N4810 , [dcl.decl]/4 had a weaker requirement for where requires-clauses were allowed to appear:

The optional requires-clause (Clause 13) in an init-declarator or member-declarator shall not be present when the declarator does not declare a function (9.2.3.5). [...]

[ Example:

 void f1(int a) requires true; // OK //...

— end example ]

where the non-normative example of the use case of the OP was explicitly shown as well-formed. The original intent there was arguably to allow constraining of non-template member functions of class templates based on the template parameters of the class template:

#include <iostream>

template<bool B>
struct S {
    void f() requires   B  { std::cout << "true\n"; }
    void f() requires (!B) { std::cout << "false\n"; }
};

int main() { 
    S<true>{}.f();   // true
    S<false>{}.f();  // false
} 

this is still allowed in the final state (intended for C++20) of [dcl.decl]/4 in N4861, where the restriction is to that of a templated function (see templated entity in [temp.pre]/8 , particularly [temp.pre]/8.3 ), which does not only cover function templates (and function template members of non-templates and template class templates), but also non-template member functions of class templates.

---

Clang bug report:

• Bug 48870 - Accepts-invalid for requires-clause on non-templated function