[clang][Interp] Emit correct diagnostic for uninitialized reads

[tbaeder]

Summary

This fixes a long standing diagnostic difference between the two interpreters.

[cor3ntin]

LGTM but please make sure to run clang-format before commiting.

clang/lib/AST/Interp/Interp.cpp

 
 bool CheckInitialized(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
                       AccessKinds AK) {
   if (Ptr.isInitialized())
     return true;
 
   if (!S.checkingPotentialConstantExpression()) {
     const SourceInfo &Loc = S.Current->getSource(OpPC);
-    S.FFDiag(Loc, diag::note_constexpr_access_uninit) << AK << false;
+    S.FFDiag(Loc, diag::note_constexpr_access_uninit)
+        << AK << /*uninitialized=*/true;
   }
   return false;
 }
 
 bool CheckLoad(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
   if (!CheckLive(S, OpPC, Ptr, AK_Read))
     return false;
   if (!CheckExtern(S, OpPC, Ptr))

clang/test/AST/Interp/constexpr-nqueens.cpp

struct Board {
   bool Failed;
 
   constexpr Board() : Failed(false) {}
   constexpr Board(const Board &O) : Failed(O.Failed) {}
   constexpr Board(uint64_t State, bool Failed = false) :
     Failed(Failed) {}
   constexpr Board addQueen(int Row, int Col) const {
     return Board(State | ((uint64_t)Row << (Col * 4))); // ref-note {{read of uninitialized object}} \
-                                                        // expected-note {{read of object outside its lifetime}}
+                                                        // expected-note {{read of uninitialized object}}
   }
   constexpr int getQueenRow(int Col) const {
     return (State >> (Col * 4)) & 0xf;
   }
   constexpr bool ok(int Row, int Col) const {
     return okRecurse(Row, Col, 0);
   }
   constexpr bool okRecurse(int Row, int Col, int CheckCol) const {

clang/test/AST/Interp/cxx20.cpp

constexpr int pointerAssign2() {
 
   return v;
 }
 static_assert(pointerAssign2() == 12, "");
 
 constexpr int unInitLocal() {
   int a;
   return a; // ref-note {{read of uninitialized object}} \
-            // expected-note {{read of object outside its lifetime}}
-            // FIXME: ^^^ Wrong diagnostic.
+            // expected-note {{read of uninitialized object}}
 }
 static_assert(unInitLocal() == 0, ""); // ref-error {{not an integral constant expression}} \
                                        // ref-note {{in call to 'unInitLocal()'}} \
                                        // expected-error {{not an integral constant expression}} \
                                        // expected-note {{in call to 'unInitLocal()'}} \
 
 constexpr int initializedLocal() {
   int a;
   a = 20;
   return a;
 }
 static_assert(initializedLocal() == 20);
 
 constexpr int initializedLocal2() {
   int a[2];
-  return *a; // expected-note {{read of object outside its lifetime}} \
+  return *a; // expected-note {{read of uninitialized object is not allowed in a constant expression}} \
              // ref-note {{read of uninitialized object is not allowed in a constant expression}}
 }
 static_assert(initializedLocal2() == 20); // expected-error {{not an integral constant expression}} \
                                           // expected-note {{in call to}} \
                                           // ref-error {{not an integral constant expression}} \
                                           // ref-note {{in call to}}
 
 
 struct Int { int a; };
 constexpr int initializedLocal3() {
   Int i;
   return i.a; // ref-note {{read of uninitialized object is not allowed in a constant expression}} \
-              // expected-note {{read of object outside its lifetime}}
+              // expected-note {{read of uninitialized object}}
 }
 static_assert(initializedLocal3() == 20); // expected-error {{not an integral constant expression}} \
                                           // expected-note {{in call to}} \
                                           // ref-error {{not an integral constant expression}} \
                                           // ref-note {{in call to}}
 
 
 
namespace BaseInit {
   struct Final : Intermediate {
     int c;
 
     constexpr Final(int a, int b, int c) : c(c) {}
   };
 
   static_assert(Final{1, 2, 3}.c == 3, ""); // OK
   static_assert(Final{1, 2, 3}.a == 0, ""); // expected-error {{not an integral constant expression}} \
-                                            // expected-note {{read of object outside its lifetime}} \
+                                            // expected-note {{read of uninitialized object}} \
                                             // ref-error {{not an integral constant expression}} \
                                             // ref-note {{read of uninitialized object}}
 
 
   struct Mixin  {
     int b;
 
     constexpr Mixin() = default;
     constexpr Mixin(int b) : b(b) {}
   };
 
   struct Final2 : Base, Mixin {
     int c;
 
     constexpr Final2(int a, int b, int c) : Mixin(b), c(c) {}
     constexpr Final2(int a, int b, int c, bool) : c(c) {}
   };
 
   static_assert(Final2{1, 2, 3}.c == 3, ""); // OK
   static_assert(Final2{1, 2, 3}.b == 2, ""); // OK
   static_assert(Final2{1, 2, 3}.a == 0, ""); // expected-error {{not an integral constant expression}} \
-                                             // expected-note {{read of object outside its lifetime}} \
+                                             // expected-note {{read of uninitialized object}} \
                                              // ref-error {{not an integral constant expression}} \
                                              // ref-note {{read of uninitialized object}}
 
 
   struct Mixin3  {
     int b;
   };
 
   struct Final3 : Base, Mixin3 {
     int c;
 
     constexpr Final3(int a, int b, int c) : c(c) { this->b = b; }
     constexpr Final3(int a, int b, int c, bool) : c(c) {}
   };
 
   static_assert(Final3{1, 2, 3}.c == 3, ""); // OK
   static_assert(Final3{1, 2, 3}.b == 2, ""); // OK
   static_assert(Final3{1, 2, 3}.a == 0, ""); // expected-error {{not an integral constant expression}} \
-                                             // expected-note {{read of object outside its lifetime}} \
+                                             // expected-note {{read of uninitialized object}} \
                                              // ref-error {{not an integral constant expression}} \
                                              // ref-note {{read of uninitialized object}}
 };
 
 namespace Destructors {
 
   class Inc final {
   public:

clang/test/AST/Interp/literals.cpp

namespace IncDec {
   }
   static_assert(incBool(), "");
 
   template<typename T, bool Inc>
   constexpr int uninit() {
     T a;
     if constexpr (Inc)
       ++a; // ref-note 2{{increment of uninitialized}} \
-           // expected-note 2{{increment of object outside its lifetime}}
+           // expected-note 2{{increment of uninitialized}}
     else
       --a; // ref-note 2{{decrement of uninitialized}} \
-           // expected-note 2{{decrement of object outside its lifetime}}
+           // expected-note 2{{decrement of uninitialized}}
     return 1;
   }
   static_assert(uninit<int, true>(), ""); // ref-error {{not an integral constant expression}} \
                                           // ref-note {{in call to 'uninit()'}} \
                                           // expected-error {{not an integral constant expression}} \
                                           // expected-note {{in call to 'uninit()'}}
 
   static_assert(uninit<int, false>(), ""); // ref-error {{not an integral constant expression}} \

clang/test/AST/Interp/records.cpp

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-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}}
+                                 // expected-note {{read of uninitialized object}}
 #endif
 
   struct AnotherBase {
     int Val;
     constexpr AnotherBase(int i) : Val(12 / i) {} //ref-note {{division by zero}} \
                                                   //expected-note {{division by zero}}
   };
 

 ///   This pointer of the current stack frame. This is something we haven't
 ///   implemented in the new interpreter yet.
 namespace DeclRefs {
   struct A{ int m; const int &f = m; }; // expected-note {{implicit use of 'this'}}
 
   constexpr A a{10}; // expected-error {{must be initialized by a constant expression}}
   static_assert(a.m == 10, "");
   static_assert(a.f == 10, ""); // expected-error {{not an integral constant expression}} \
-                                // expected-note {{read of object outside its lifetime}}
+                                // expected-note {{read of uninitialized object}}
 
   class Foo {
   public:
     int z = 1337;
     constexpr int a() const {
       A b{this->z};
 
       return b.f;