[concepts] Implement dcl.decl.general p4: No constraints on non-template funcs

[erichkeane]

Summary

The standard says:

The optional requires-clause ([temp.pre]) in an init-declarator or
member-declarator shall be present only if the declarator declares a
templated function ([dcl.fct]).

This implements that limitation, and updates the tests to the best of my
ability to capture the intent of the original checks.

[royjacobson]

Code and added/modified tests LGTM!

Do you think we should add a release note, given that it could break existing code? Its seems a bit unlikely, but the amount of broken tests have made me a bit worried.
Also, maybe mention the github issue (https://github.com/llvm/llvm-project/issues/51173) in the commit message.

clang/test/Parser/cxx-concepts-requires-clause.cpp

145

[erichkeane]

In D125711#3517065, @royjacobson wrote:

Code and added/modified tests LGTM!

Do you think we should add a release note, given that it could break existing code? Its seems a bit unlikely, but the amount of broken tests have made me a bit worried.
Also, maybe mention the github issue (https://github.com/llvm/llvm-project/issues/51173) in the commit message.

Thanks for the review! I absolutely need a release note, I'll add one before committing.

clang/docs/ReleaseNotes.rst

- Improved ``-O0`` code generation for calls to ``std::move``, ``std::forward``,
   are now treated as compiler builtins and implemented directly, rather than
   instantiating the definition from the standard library.
 - Fixed mangling of nested dependent names such as ``T::a::b``, where ``T`` is a
   template parameter, to conform to the Itanium C++ ABI and be compatible with
   GCC. This breaks binary compatibility with code compiled with earlier versions
   of clang; use the ``-fclang-abi-compat=14`` option to get the old mangling.
 - Preprocessor character literals with a ``u8`` prefix are now correctly treated as
   unsigned character literals. This fixes `Issue 54886 <https://github.com/llvm/llvm-project/issues/54886>`_.
+- Stopped allowing constriants on non-template functions to be compliant with
+  dcl.decl.general p4.
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 - Diagnose consteval and constexpr issues that happen at namespace scope. This
   partially addresses `Issue 51593 <https://github.com/llvm/llvm-project/issues/51593>`_.
 - No longer attempt to evaluate a consteval UDL function call at runtime when
   it is called through a template instantiation. This fixes
   `Issue 54578 <https://github.com/llvm/llvm-project/issues/54578>`_.

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def note_single_arg_concept_specialization_constraint_evaluated_to_false : Note<
   "%select{and|because}0 %1 does not satisfy %2">;
 def note_atomic_constraint_evaluated_to_false_elaborated : Note<
   "%select{and|because}0 '%1' (%2 %3 %4) evaluated to false">;
 def err_constrained_virtual_method : Error<
   "virtual function cannot have a requires clause">;
 def err_trailing_requires_clause_on_deduction_guide : Error<
   "deduction guide cannot have a requires clause">;
+def err_constrained_non_templated_function
+    : Error<"non-templated function cannot have a requires clause">;
 def err_reference_to_function_with_unsatisfied_constraints : Error<
   "invalid reference to function %0: constraints not satisfied">;
 def err_requires_expr_local_parameter_default_argument : Error<
   "default arguments not allowed for parameters of a requires expression">;
 def err_requires_expr_parameter_referenced_in_evaluated_context : Error<
   "constraint variable %0 cannot be used in an evaluated context">;
 def note_expr_requirement_expr_substitution_error : Note<
   "%select{and|because}0 '%1' would be invalid: %2">;

clang/lib/Sema/SemaDecl.cpp

if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
         // A virtual method shall not have a requires-clause.
         Diag(NewFD->getTrailingRequiresClause()->getBeginLoc(),
              diag::err_constrained_virtual_method);
 
       if (Method->isStatic())
         checkThisInStaticMemberFunctionType(Method);
     }
 
+    // C++20: dcl.decl.general p4:
+    // The optional requires-clause ([temp.pre]) in an init-declarator or
+    // member-declarator shall be present only if the declarator declares a
+    // templated function ([dcl.fct]).
+    if (Expr *TRC = NewFD->getTrailingRequiresClause()) {
+      if (!NewFD->isTemplated() && !NewFD->isTemplateInstantiation())
+        Diag(TRC->getBeginLoc(), diag::err_constrained_non_templated_function);
+    }
+
     if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(NewFD))
       ActOnConversionDeclarator(Conversion);
 
     // Extra checking for C++ overloaded operators (C++ [over.oper]).
     if (NewFD->isOverloadedOperator() &&
         CheckOverloadedOperatorDeclaration(NewFD)) {
       NewFD->setInvalidDecl();
       return Redeclaration;

clang/test/CXX/dcl.decl/dcl.decl.general/p4-20.cpp

+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
+
+// expected-error@+2 {{non-templated function cannot have a requires clause}}
+void f1(int a)
+  requires true;
+template <typename T>
+auto f2(T a) -> bool
+  requires true; // OK
+
+// expected-error@+4 {{trailing return type must appear before trailing requires clause}}
+template <typename T>
+auto f3(T a)
+  requires true
+-> bool;
+
+// expected-error@+2{{trailing requires clause can only be used when declaring a function}}
+void (*pf)()
+  requires true;
+
+// expected-error@+1{{trailing requires clause can only be used when declaring a function}}
+void g(int (*)() requires true);
+
+// expected-error@+1{{expected expression}}
+auto *p = new void(*)(char)
+  requires true;

clang/test/CXX/dcl/dcl.decl/p3.cpp

 // RUN:  %clang_cc1 -std=c++2a -verify %s
 
 template<typename T, typename U>
 constexpr bool is_same_v = false;
 
 template<typename T>
 constexpr bool is_same_v<T, T> = true;
 
-void f1(int a) requires true; // OK
-auto f2(int a) -> bool requires true; // OK
+using T = void ();
+
+void f1non_templ(int a) requires true; // expected-error{{non-templated function cannot have a requires clause}}
+auto f2non_templ(int a) -> bool requires true; // expected-error{{non-templated function cannot have a requires clause}}
+auto f3non_templ(int a) -> bool (*)(int b) requires true; // expected-error{{non-templated function cannot have a requires clause}}
+// expected-error@+1{{non-templated function cannot have a requires clause}}
+auto f4_non_templ(int a) requires true -> bool; // expected-error{{trailing return type must appear before trailing requires clause}}
+void (f7non_templ()) requires true; // expected-error{{non-templated function cannot have a requires clause}}
+// expected-error@+1{{non-templated function cannot have a requires clause}}
+void (f8non_templ() requires true); // expected-error{{trailing requires clause should be placed outside parentheses}}
+// expected-error@+1{{non-templated function cannot have a requires clause}}
+T xnon_templ requires true;
+// expected-error@+2 2{{non-templated function cannot have a requires clause}}
+struct Snon_templ {
+  T m1 requires true, m2 requires true;
+};
+
+template <typename>
+void f1(int a)
+  requires true;                               // OK
+
+template <typename>
+auto f2(int a) -> bool
+  requires true;                                 // OK
+
+template <typename>
 auto f3(int a) -> bool (*)(int b) requires true; // OK
+template <typename>
 auto f4(int a) requires true -> bool; // expected-error{{trailing return type must appear before trailing requires clause}}
 int f5(int a) requires; // expected-error{{expected expression}}
 int f6(int a) requires {} // expected-error{{expected expression}}
+template<typename>
 void (f7()) requires true;
+template<typename>
 void (f8() requires true); // expected-error{{trailing requires clause should be placed outside parentheses}}
 void (*(f9 requires (true)))(); // expected-error{{trailing requires clause should be placed outside parentheses}}
 static_assert(is_same_v<decltype(f9), void (*)()>);
 void (*pf)() requires true; // expected-error{{trailing requires clause can only be used when declaring a function}}
 void g1(int (*dsdads)() requires false); // expected-error{{trailing requires clause can only be used when declaring a function}}
 void g2(int (*(*dsdads)())() requires true); // expected-error{{trailing requires clause can only be used when declaring a function}}
 void g3(int (*(*dsdads)(int) requires true)() ); // expected-error{{trailing requires clause should be placed outside parentheses}}
-using T = void ();
+
+template<typename U>
+struct Foo{
 T x requires true;
+};
+Foo<int> f;
+
+template<typename>
 struct S {
   T m1 requires true, m2 requires true;
 };
 
 template<typename T>
 struct R {
     R(T t);
 };
 
 template<typename T>
 R(T) -> R<T> requires true; // expected-error{{deduction guide cannot have a requires clause}}

clang/test/CXX/expr/expr.prim/expr.prim.id/p4.cpp

 // RUN:  %clang_cc1 -std=c++2a -verify %s
 
 namespace functions
 {
-  void foo(int) requires false {}
+  template<typename T>
+  struct S {
+  static void foo(int) requires false {}
   // expected-note@-1 3{{because 'false' evaluated to false}}
-  // expected-note@-2 {{candidate function not viable: constraints not satisfied}}
-  void bar(int) requires true {}
+  static void bar(int) requires true {}
+  };
 
   void a(int);
   void a(double);
 
   void baz() {
-    foo(1); // expected-error{{no matching function for call to 'foo'}}
-    bar(1);
-    void (*p1)(int) = foo; // expected-error{{invalid reference to function 'foo': constraints not satisfied}}
-    void (*p3)(int) = bar;
-    decltype(foo)* a1 = nullptr; // expected-error{{invalid reference to function 'foo': constraints not satisfied}}
-    decltype(bar)* a2 = nullptr;
+    S<int>::foo(1); // expected-error{{invalid reference to function 'foo': constraints not satisfied}}
+    S<int>::bar(1);
+    void (*p1)(int) = S<int>::foo; // expected-error{{invalid reference to function 'foo': constraints not satisfied}}
+    void (*p3)(int) = S<int>::bar;
+    decltype(S<int>::foo)* a1 = nullptr; // expected-error{{invalid reference to function 'foo': constraints not satisfied}}
+    decltype(S<int>::bar)* a2 = nullptr;
   }
 }
 
 namespace methods
 {
   template<typename T>
   struct A {
     static void foo(int) requires (sizeof(T) == 1) {} // expected-note 3{{because 'sizeof(char[2]) == 1' (2 == 1) evaluated to false}}

clang/test/CXX/over/over.match/over.match.best/p1-2a.cpp

 namespace non_template
 {
   template<typename T>
   concept AtLeast2 = sizeof(T) >= 2;
 
   template<typename T>
   concept AtMost8 = sizeof(T) <= 8;
 
+  template<typename T>
   int foo() requires AtLeast2<long> && AtMost8<long> {
     return 0;
   }
 
+  template<typename T>
   double foo() requires AtLeast2<long> {
     return 0.0;
   }
 
+  template<typename T>
   double baz() requires AtLeast2<long> && AtMost8<long> { // expected-note {{candidate function}}
     return 0.0;
   }
 
+  template<typename T>
   int baz() requires AtMost8<long> && AtLeast2<long> { // expected-note {{candidate function}}
     return 0.0;
   }
 
+  template<typename T>
   void bar() requires (sizeof(char[8]) >= 8) { }
   // expected-note@-1 {{candidate function}}
   // expected-note@-2 {{similar constraint expressions not considered equivalent}}
 
+  template<typename T>
   void bar() requires (sizeof(char[8]) >= 8 && sizeof(int) <= 30) { }
   // expected-note@-1 {{candidate function}}
   // expected-note@-2 {{similar constraint expression here}}
 
-  static_assert(is_same_v<decltype(foo()), int>);
-  static_assert(is_same_v<decltype(baz()), int>); // expected-error {{call to 'baz' is ambiguous}}
-  static_assert(is_same_v<decltype(bar()), void>); // expected-error {{call to 'bar' is ambiguous}}
-  
+  static_assert(is_same_v<decltype(foo<int>()), int>);
+  static_assert(is_same_v<decltype(baz<int>()), int>); // expected-error {{call to 'baz' is ambiguous}}
+  static_assert(is_same_v<decltype(bar<int>()), void>); // expected-error {{call to 'bar' is ambiguous}}
+  template<typename T>
   constexpr int goo(int a) requires AtLeast2<int> && true {
     return 1;
   }
 
+  template<typename T>
   constexpr int goo(const int b) requires AtLeast2<int> {
     return 2;
   }
 
   // Only trailing requires clauses of redeclarations are compared for overload resolution.
+  template<typename T>
   constexpr int doo(int a, ...) requires AtLeast2<int> && true { // expected-note {{candidate function}}
     return 1;
   }
 
+  template<typename T>
   constexpr int doo(int b) requires AtLeast2<int> { // expected-note {{candidate function}}
     return 2;
   }
 
-  static_assert(goo(1) == 1);
-  static_assert(doo(2) == 1); // expected-error {{call to 'doo' is ambiguous}}
+  static_assert(goo<int>(1) == 1);
+  static_assert(doo<int>(2) == 1); // expected-error {{call to 'doo' is ambiguous}}
 }

clang/test/CXX/over/over.match/over.match.viable/p3.cpp

 // RUN:  %clang_cc1 -std=c++2a -verify %s
 
 struct S2 {};
-// expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'S1' to 'const S2' for 1st argument}}
-// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'S1' to 'S2' for 1st argument}}
+// expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'S1<int>' to 'const S2' for 1st argument}}
+// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'S1<int>' to 'S2' for 1st argument}}
 // expected-note@-3 {{candidate constructor (the implicit default constructor) not viable: requires 0 arguments, but 1 was provided}}
 
+template<typename T>
 struct S1 {
   void foo() const requires true {}
   void foo() const requires false {}
   void bar() const requires false {}
   // expected-note@-1 {{because 'false' evaluated to false}}
   operator bool() const requires true { return true; }
   explicit operator bool() const requires false;
   explicit operator S2() const requires false;
   // expected-note@-1 {{candidate function not viable: constraints not satisfied}}
   // expected-note@-2 {{because 'false' evaluated to false}}
 };
 
 void foo() {
-  S1().foo();
-  S1().bar();
+  S1<int>().foo();
+  S1<int>().bar();
   // expected-error@-1 {{invalid reference to function 'bar': constraints not satisfied}}
-  (void) static_cast<bool>(S1());
-  (void) static_cast<S2>(S1());
-  // expected-error@-1 {{no matching conversion for static_cast from 'S1' to 'S2'}}
+  (void) static_cast<bool>(S1<int>());
+  (void) static_cast<S2>(S1<int>());
+  // expected-error@-1 {{no matching conversion for static_cast from 'S1<int>' to 'S2'}}
 }
 
 // Test that constraints are checked before implicit conversions are formed.
 
 template<typename T>
 struct invalid_template { using X = typename T::non_existant; };
 struct A {
   template<typename T, bool=invalid_template<T>::aadasas>
   operator T() {}
 };
 
-void foo(int) requires false;
-void foo(A) requires true;
+template<typename>
+struct WrapsStatics {
+  static void foo(int) requires false;
+  static void foo(A) requires true;
+};
 
+template<typename T>
 struct S {
   void foo(int) requires false;
   void foo(A) requires true;
   S(A) requires false;
   S(double) requires true;
   ~S() requires false;
   // expected-note@-1 2{{because 'false' evaluated to false}}
   ~S() requires true;
   operator int() requires true;
   operator int() requires false;
 };
 
 void bar() {
-  foo(A{});
-  S{1.}.foo(A{});
+  WrapsStatics<int>::foo(A{});
+  S<int>{1.}.foo(A{});
   // expected-error@-1{{invalid reference to function '~S': constraints not satisfied}}
   // Note - this behavior w.r.t. constrained dtors is a consequence of current
   // wording, which does not invoke overload resolution when a dtor is called.
   // P0848 is set to address this issue.
-  S s = 1;
+  S<int> s = 1;
   // expected-error@-1{{invalid reference to function '~S': constraints not satisfied}}
   int a = s;
-}
+}
 

clang/test/CXX/over/over.over/p4-2a.cpp

 // RUN:  %clang_cc1 -std=c++2a -verify %s
 
 template<typename T, typename U>
 constexpr static bool is_same_v = false;
 
 template<typename T>
 constexpr static bool is_same_v<T, T> = true;
 
 template<typename T>
 concept AtLeast2 = sizeof(T) >= 2;
 
 template<typename T>
 concept AtMost8 = sizeof(T) <= 8;
 
-int foo() requires AtLeast2<long> && AtMost8<long> {
+template<typename T>
+struct S {
+static int foo() requires AtLeast2<long> && AtMost8<long> {
   return 0;
 }
 
-double foo() requires AtLeast2<char> {
+static double foo() requires AtLeast2<char> {
   return 0.0;
 }
 
-char bar() requires AtLeast2<char> { // expected-note {{possible target for call}}
+static char bar() requires AtLeast2<char> {
   return 1.0;
 }
 
-short bar() requires AtLeast2<long> && AtMost8<long> {
-// expected-note@-1{{possible target for call}}
-// expected-note@-2{{candidate function}}
+static short bar() requires AtLeast2<long> && AtMost8<long> {
   return 0.0;
 }
 
-int bar() requires AtMost8<long> && AtLeast2<long> {
-// expected-note@-1{{possible target for call}}
-// expected-note@-2{{candidate function}}
+static int bar() requires AtMost8<long> && AtLeast2<long> {
   return 0.0;
 }
 
-char baz() requires AtLeast2<char> {
+static char baz() requires AtLeast2<char> {
   return 1.0;
 }
 
-short baz() requires AtLeast2<long> && AtMost8<long> {
+static short baz() requires AtLeast2<long> && AtMost8<long> {
   return 0.0;
 }
 
-int baz() requires AtMost8<long> && AtLeast2<long> {
+static int baz() requires AtMost8<long> && AtLeast2<long> {
   return 0.0;
 }
 
-long baz() requires AtMost8<long> && AtLeast2<long> && AtLeast2<short> {
+static long baz() requires AtMost8<long> && AtLeast2<long> && AtLeast2<short> {
   return 3.0;
 }
+};
 
 void a() {
-  static_assert(is_same_v<decltype(&foo), int(*)()>);
-  static_assert(is_same_v<decltype(&bar), long(*)()>);
-  // expected-error@-1{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
-  // expected-error@-2{{call to 'bar' is ambiguous}}
-  static_assert(is_same_v<decltype(&baz), long(*)()>);
-}
+  static_assert(is_same_v<decltype(&S<int>::foo), int(*)()>);
+  static_assert(is_same_v<decltype(&S<int>::bar), long(*)()>);
+  // expected-error@-1{{reference to overloaded function could not be resolved; did you mean to call it?}}
+  static_assert(is_same_v<decltype(&S<int>::baz), long(*)()>);
+}
 

clang/test/Parser/cxx-concepts-requires-clause.cpp

 template<typename T>
 void bar() requires sizeof(T) == 0;
 // expected-error@-1{{parentheses are required around this expression in a requires clause}}
 
 template<typename T>
 void bar() requires (sizeof(T)) == 0;
 // expected-error@-1{{parentheses are required around this expression in a requires clause}}
 
+template<typename T>
 void bar(int x, int y) requires (x, y, true);
 
+template<typename T>
 struct B {
   int x;
   void foo(int y) requires (x, this, this->x, y, true);
   static void bar(int y) requires (x, true);
   // expected-error@-1{{'this' cannot be implicitly used in a static member function declaration}}
   static void baz(int y) requires (this, true);
   // expected-error@-1{{'this' cannot be used in a static member function declaration}}
 };

clang/test/Parser/cxx2a-concepts-requires-expr.cpp

 bool r34 = requires { 0 int; };
 // expected-error@-1 {{expected ';' at end of requirement}}
 
 bool r35 = requires { requires true };
 // expected-error@-1 {{expected ';' at end of requirement}}
 
 bool r36 = requires (bool b) { requires sizeof(b) == 1; };
 
+template<typename T>
 void r37(bool b) requires requires { 1 } {}
 // expected-error@-1 {{expected ';' at end of requirement}}
 
 bool r38 = requires { requires { 1; }; };
 // expected-error@-1 {{requires expression in requirement body; did you intend to place it in a nested requirement? (add another 'requires' before the expression)}}
 
 bool r39 = requires { requires () { 1; }; };
 // expected-error@-1 {{requires expression in requirement body; did you intend to place it in a nested requirement? (add another 'requires' before the expression)}}

clang/test/SemaCXX/cxx20-check-fptr-constraints.cpp

 // RUN: %clang_cc1 -std=c++20 -verify %s
 
 namespace P1972 {
-void f(int) requires false; // expected-note 4{{because 'false' evaluated to false}} \
-                            // expected-note{{constraints not satisfied}}
+template <typename T>
+struct S {
+  static void f(int)
+    requires false; // expected-note 4{{because 'false' evaluated to false}}
+};
 void g() {
-  f(0);                      // expected-error{{no matching function for call to 'f'}}
-  void (*p1)(int) = f;       // expected-error{{invalid reference to function 'f': constraints not satisfied}}
-  void (*p21)(int) = &f;     // expected-error{{invalid reference to function 'f': constraints not satisfied}}
-  decltype(f) *p2 = nullptr; // expected-error{{invalid reference to function 'f': constraints not satisfied}}
+  S<int>::f(0);                      // expected-error{{invalid reference to function 'f': constraints not satisfied}}
+  void (*p1)(int) = S<int>::f;       // expected-error{{invalid reference to function 'f': constraints not satisfied}}
+  void (*p21)(int) = &S<int>::f;     // expected-error{{invalid reference to function 'f': constraints not satisfied}}
+  decltype(S<int>::f) *p2 = nullptr; // expected-error{{invalid reference to function 'f': constraints not satisfied}}
 }
 }