[clang][Interp] Fix diagnostics for calling non-constexpr constructors

[tbaeder]

Ping

[aaron.ballman]

LGTM

clang/test/AST/Interp/records.cpp

353

clang/lib/AST/Interp/ByteCodeExprGen.cpp

 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::visitRecordInitializer(const Expr *Initializer) {
   Initializer = Initializer->IgnoreParenImpCasts();
   assert(Initializer->getType()->isRecordType());
 
   if (const auto CtorExpr = dyn_cast<CXXConstructExpr>(Initializer)) {
     const Function *Func = getFunction(CtorExpr->getConstructor());
 
-    if (!Func || !Func->isConstexpr())
+    if (!Func)
       return false;
 
     // The This pointer is already on the stack because this is an initializer,
     // but we need to dup() so the call() below has its own copy.
     if (!this->emitDupPtr(Initializer))
       return false;
 
     // Constructor arguments.

clang/test/AST/Interp/cxx20.cpp

 };
 
 namespace ConstThis {
   class Foo {
     const int T = 12; // expected-note {{declared const here}} \
                       // ref-note {{declared const here}}
     int a;
   public:
-    constexpr Foo() {
+    constexpr Foo() { // expected-note {{declared here}}
       this->a = 10;
       T = 13; // expected-error {{cannot assign to non-static data member 'T' with const-qualified type}} \
               // ref-error {{cannot assign to non-static data member 'T' with const-qualified type}}
     }
   };
   constexpr Foo F; // expected-error {{must be initialized by a constant expression}} \
+                   // FIXME: The following note is wrong. \
+                   // expected-note {{undefined constructor 'Foo' cannot be used in a constant expression}} \
                    // ref-error {{must be initialized by a constant expression}}
 
 
   class FooDtor {
     int a;
   public:
     constexpr FooDtor() {
       this->a = 10;

clang/test/AST/Interp/records.cpp

class D : private A, private B {
     constexpr int getB() const { return b; }
   };
   constexpr D d = {};
   static_assert(d.getA() == 20, "");
   static_assert(d.getB() == 30, "");
 };
 
 namespace DeriveFailures {
-  struct Base { // ref-note 2{{declared here}}
+  struct Base { // ref-note 2{{declared here}} expected-note {{declared here}}
     int Val;
   };
 
   struct Derived : Base {
     int OtherVal;
 
     constexpr Derived(int i) : OtherVal(i) {} // ref-error {{never produces a constant expression}} \
-                                              // ref-note 2{{non-constexpr constructor 'Base' cannot be used in a constant expression}}
+                                              // ref-note 2{{non-constexpr constructor 'Base' cannot be used in a constant expression}} \
+                                              // expected-note {{non-constexpr constructor 'Base' cannot be used in a constant expression}}
   };
 
   constexpr Derived D(12); // ref-error {{must be initialized by a constant expression}} \
                            // ref-note {{in call to 'Derived(12)'}} \
                            // ref-note {{declared here}} \
-                           // expected-error {{must be initialized by a constant expression}}
+                           // expected-error {{must be initialized by a constant expression}} \
+                           // expected-note {{in call to 'Derived(12)'}}
   static_assert(D.Val == 0, ""); // ref-error {{not an integral constant expression}} \
                                  // ref-note {{initializer of 'D' is not a constant expression}} \
                                  // expected-error {{not an integral constant expression}} \
                                  // expected-note {{read of object outside its lifetime}}
 
   struct AnotherBase {
     int Val;
     constexpr AnotherBase(int i) : Val(12 / i) {} //ref-note {{division by zero}} \
constexpr AnotherBase Derp(0); // ref-error {{must be initialized by a constant expression}} \
                                  // expected-note {{in call to 'AnotherBase(0)'}}
 
   struct YetAnotherBase {
     int Val;
     constexpr YetAnotherBase(int i) : Val(i) {}
   };
 
   struct YetAnotherDerived : YetAnotherBase {
-    using YetAnotherBase::YetAnotherBase; //ref-note {{declared here}}
+    using YetAnotherBase::YetAnotherBase; //ref-note {{declared here}} expected-note {{declared here}}
     int OtherVal;
 
     constexpr bool doit() const { return Val == OtherVal; }
   };
 
   constexpr YetAnotherDerived Oops(0); // ref-error {{must be initialized by a constant expression}} \
                                        // ref-note {{constructor inherited from base class 'YetAnotherBase' cannot be used in a constant expression}} \
-                                       // expected-error {{must be initialized by a constant expression}}
-                                       // FIXME: Missing reason for rejection.
+                                       // expected-error {{must be initialized by a constant expression}} \
+                                       // expected-note {{constructor inherited from base class 'YetAnotherBase' cannot be used in a constant expression}}
 };
 
 namespace EmptyCtor {
   struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
   constexpr piecewise_construct_t piecewise_construct =
     piecewise_construct_t();
 };