[C++20] Correctly handle constexpr/consteval explicitly defaulted special member instantiation behavior

[aaron.ballman]

Summary

When instantiating a class template, if the primary class template special member function declaration was declared constexpr or consteval, the instantiation is also considered to be a consteval function even if the instantiation would not be valid to use in a constant expression (http://eel.is/c++draft/dcl.constexpr#7). However, when instantiating such a class, we were incorrectly saying the special member was not a constexpr function when a base class or member variable would cause the instantiation to not be usable in a constant expression. This addresses the issue by falling back to the primary declaration of the explicitly defaulted special member function.

This caused some unexpected test failures with friend declaration checking, but the standard is quite unclear on what's expected there. We also have existing bugs in that particular area (https://godbolt.org/z/cPKGvx746). I raised some questions on the Core reflectors about what is expected and put a FIXME into the test to make it clear that's unresolved.

[rsmith]

clang/lib/AST/DeclCXX.cpp

1315–1316

Incidentally: this was fixed in DR1361, a long time ago. We can remove this comment.

1319

Shouldn't this be looking in the class template itself? It doesn't seem correct to use things like this->hasConstexprDefaultConstructor() from here, because we've not finished gathering the data that contributes to that function's return value yet.

That said... I don't think that changing DefaultedDefaultConstructorIsConstexpr can work here. Keep in mind that a class can have more than one default constructor, and in C++20 onwards can even have more than one defaulted default constructor. This flag needs to apply to all of them, and only some subset of them might have been declared as constexpr in the template from which they are instantiated. So this flag should be answering the question, "is a defaulted default constructor *implicitly* constexpr?", and any callers that are assuming that it means "will this particular defaulted default constructor be constexpr?" should be changed to take into account whether the default constructor is explicitly declared as constexpr.

clang/lib/Sema/SemaDeclCXX.cpp

7555–7556

It would be clearer and more in line with the wording to ask if MD is instantiated here, rather than to ask if the class is being instantiated (though the two are presumably equivalent because you can't instantiate a constructor template to form a special member function).

7576

I think we'll now treat instantiated constructors and non-instantiated ones differently here:

#ifdef TEMPLATE
template<typename T>
#endif
struct S {
  constexpr S() = default;
  TypeWithThrowingConstructor x;
};

In the templated case, the instantiation's constructor will be constexpr, but in the non-template case it won't be. That doesn't seem consistent. It would be cleaner and would probably require fewer special cases if we treated both cases the same: if you specify constexpr, you get a constexpr function, always, but we'll generate an error message if the function is non-templated and wouldn't have been implicitly constexpr.

clang/test/SemaCXX/cxx2a-consteval.cpp

774

This diagnostic demonstrates that we're not doing the proper checking here: we do attempt to call a constexpr constructor that doesn't satisfy the constexpr requirements, even though we're not supposed to. IIRC we try to hand-wave our way to conformance here by saying that all of the things that cause a constexpr constructor to fail to satisfy the constexpr requirements would also cause evaluation to fail, but it'd be worth double-checking that (in particular: what happens if the class has a virtual base class?).

[aaron.ballman]

This was partially covered by https://reviews.llvm.org/D131479 and the rest should be handled in a different patch, so abandoning.

clang/docs/ReleaseNotes.rst

 
 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>`_.
-
+- Properly determine whether an instantiated, explicitly defaulted constexpr or
+  consteval special member function is still considered to be constexpr or
+  consteval instead of calculating it purely from the bases and fields of the
+  class being instantiated.
 - Implemented ``__builtin_source_location()``, which enables library support
   for ``std::source_location``.
 
 - The mangling scheme for C++20 modules has incompatibly changed. The
   initial mangling was discovered not to be reversible, and the weak
   ownership design decision did not give the backwards compatibility
   that was hoped for. C++20 since added ``extern "C++"`` semantics
   that can be used for such compatibility. The demangler now demangles

clang/lib/AST/DeclCXX.cpp

 
         // C++11 [class.copy]p13:
         //   If the implicitly-defined constructor would satisfy the
         //   requirements of a constexpr constructor, the implicitly-defined
         //   constructor is constexpr.
         // C++11 [dcl.constexpr]p4:
         //    -- every constructor involved in initializing non-static data
         //       members [...] shall be a constexpr constructor
+        // C++14 [dcl.constexpr]p6 (CWG DR647/CWG DR1358):
+        //   If the instantiated template specialization of a constexpr
+        //   function template or member function of a class template would
+        //   fail to satisfy the requirements for a constexpr function or
+        //   constexpr constructor, that specialization is still a constexpr
+        //   function or constexpr constructor, even though a call to such a
+        //   function cannot appear in a constant expression.
         if (!Field->hasInClassInitializer() &&
             !FieldRec->hasConstexprDefaultConstructor() && !isUnion())
           // The standard requires any in-class initializer to be a constant
           // expression. We consider this to be a defect.
-          data().DefaultedDefaultConstructorIsConstexpr = false;
+          data().DefaultedDefaultConstructorIsConstexpr =
+              isa<ClassTemplateSpecializationDecl>(this)
+                  ? hasConstexprDefaultConstructor()
+                  : false;
 
         // C++11 [class.copy]p8:
         //   The implicitly-declared copy constructor for a class X will have
         //   the form 'X::X(const X&)' if each potentially constructed subobject
         //   of a class type M (or array thereof) has a copy constructor whose
         //   first parameter is of type 'const M&' or 'const volatile M&'.
         if (!FieldRec->hasCopyConstructorWithConstParam())
           data().ImplicitCopyConstructorCanHaveConstParamForNonVBase = false;

clang/lib/Sema/SemaDeclCXX.cpp

   // Do not apply this rule to members of class templates, since core issue 1358
   // makes such functions always instantiate to constexpr functions. For
   // functions which cannot be constexpr (for non-constructors in C++11 and for
   // destructors in C++14 and C++17), this is checked elsewhere.
   //
   // FIXME: This should not apply if the member is deleted.
   bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
                                                      HasConstParam);
+
+  // C++14 [dcl.constexpr]p6 (CWG DR647/CWG DR1358):
+  //   If the instantiated template specialization of a constexpr function
+  //   template or member function of a class template would fail to satisfy
+  //   the requirements for a constexpr function or constexpr constructor, that
+  //   specialization is still a constexpr function or constexpr constructor,
+  //   even though a call to such a function cannot appear in a constant
+  //   expression.
+  if (!Constexpr && isa<ClassTemplateSpecializationDecl>(RD))
+    Constexpr = MD->isConstexpr();
+
   if ((getLangOpts().CPlusPlus20 ||
        (getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
                                   : isa<CXXConstructorDecl>(MD))) &&
       MD->isConstexpr() && !Constexpr &&
       MD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) {
     Diag(MD->getBeginLoc(), MD->isConsteval()
                                 ? diag::err_incorrect_defaulted_consteval
                                 : diag::err_incorrect_defaulted_constexpr)
         << CSM;
     // FIXME: Explain why the special member can't be constexpr.
     HadError = true;
   }
 
   if (First) {
     // C++2a [dcl.fct.def.default]p3:
     //   If a function is explicitly defaulted on its first declaration, it is
     //   implicitly considered to be constexpr if the implicit declaration
     //   would be.
     MD->setConstexprKind(Constexpr ? (MD->isConsteval()
                                           ? ConstexprSpecKind::Consteval
                                           : ConstexprSpecKind::Constexpr)
                                    : ConstexprSpecKind::Unspecified);
 
     if (!Type->hasExceptionSpec()) {
       // C++2a [except.spec]p3:
       //   If a declaration of a function does not have a noexcept-specifier
       //   [and] is defaulted on its first declaration, [...] the exception

clang/test/SemaCXX/cxx0x-defaulted-functions.cpp

 void tester() {
   foo f, g(f);
   bar b, c(b);
   f = g;
   b = c;
 }
 
 template<typename T> struct S : T {
-  constexpr S() = default;
-  constexpr S(const S&) = default;
-  constexpr S(S&&) = default;
+  constexpr S() = default;         // expected-note {{previous declaration is here}}
+  constexpr S(const S&) = default; // expected-note {{previous declaration is here}}
+  constexpr S(S&&) = default;      // expected-note {{previous declaration is here}}
 };
 struct lit { constexpr lit() {} };
 S<lit> s_lit; // ok
 S<bar> s_bar; // ok
 
 struct Friends {
-  friend S<bar>::S();
-  friend S<bar>::S(const S&);
-  friend S<bar>::S(S&&);
+  // FIXME: these error may or may not be correct; there is an open question on
+  // the CWG reflectors about this.
+  friend S<bar>::S();          // expected-error {{non-constexpr declaration of 'S' follows constexpr declaration}}
+  friend S<bar>::S(const S&);  // expected-error {{non-constexpr declaration of 'S' follows constexpr declaration}}
+  friend S<bar>::S(S&&);       // expected-error {{non-constexpr declaration of 'S' follows constexpr declaration}}
 };
 
 namespace DefaultedFnExceptionSpec {
   // DR1330: The exception-specification of an implicitly-declared special
   // member function is evaluated as needed.
   template<typename T> T &&declval();
   template<typename T> struct pair {
     pair(const pair&) noexcept(noexcept(T(declval<T>())));

clang/test/SemaCXX/cxx2a-consteval.cpp

 
 void test() {
   static_assert(f1('a') == 4);
   static_assert(f2('a') == 4);
   constexpr int c = f1('a') + f2('a');
   static_assert(c == 8);
 }
 }
+
+namespace DefaultedTemp {
+template <typename T>
+struct default_ctor {
+  T data;
+  consteval default_ctor() = default; // expected-note {{non-constexpr constructor 'foo' cannot be used in a constant expression}}
+};
+
+template <typename T>
+struct copy {
+  T data;
+
+  consteval copy(const copy &) = default;            // expected-note {{non-constexpr constructor 'foo' cannot be used in a constant expression}}
+  consteval copy &operator=(const copy &) = default; // expected-note {{non-constexpr function 'operator=' cannot be used in a constant expression}}
+  copy() = default;
+};
+
+template <typename T>
+struct move {
+  T data;
+
+  consteval move(move &&) = default;            // expected-note {{non-constexpr constructor 'foo' cannot be used in a constant expression}}
+  consteval move &operator=(move &&) = default; // expected-note {{non-constexpr function 'operator=' cannot be used in a constant expression}}
+  move() = default;
+};
+
+struct foo {
+  foo() {}            // expected-note {{declared here}}
+  foo(const foo &) {} // expected-note {{declared here}}
+  foo(foo &&) {}      // expected-note {{declared here}}
+
+  foo& operator=(const foo &) { return *this; } // expected-note {{declared here}}
+  foo& operator=(foo &&) { return *this; }      // expected-note {{declared here}}
+};
+
+void func() {
+  default_ctor<foo> fail0; // expected-error {{call to consteval function 'DefaultedTemp::default_ctor<DefaultedTemp::foo>::default_ctor' is not a constant expression}} \
+                              expected-note {{in call to 'default_ctor()'}}
+
+  copy<foo> good0;
+  copy<foo> fail1{good0}; // expected-error {{call to consteval function 'DefaultedTemp::copy<DefaultedTemp::foo>::copy' is not a constant expression}} \
+                             expected-note {{in call to 'copy(good0)'}}
+  fail1 = good0;          // expected-error {{call to consteval function 'DefaultedTemp::copy<DefaultedTemp::foo>::operator=' is not a constant expression}} \
+                             expected-note {{in call to '&fail1->operator=(good0)'}}
+
+  move<foo> good1;
+  move<foo> fail2{static_cast<move<foo>&&>(good1)}; // expected-error {{call to consteval function 'DefaultedTemp::move<DefaultedTemp::foo>::move' is not a constant expression}} \
+                                                       expected-note {{in call to 'move(good1)'}}
+  fail2 = static_cast<move<foo>&&>(good1);          // expected-error {{call to consteval function 'DefaultedTemp::move<DefaultedTemp::foo>::operator=' is not a constant expression}} \
+                                                       expected-note {{in call to '&fail2->operator=(good1)'}}
+}
+} // namespace DefaultedTemp