[clang][ExprConstant] Improve error message of compound assignment against uninitialized object

[hazohelet]

Summary

BEFORE this patch, compound assignment operator against uninitialized object such as uninit += 1 was diagnosed as subexpression not valid
This patch clarifies the reason for the error by saying that uninit is an uninitialized object.

Fixes https://github.com/llvm/llvm-project/issues/51536

[tbaeder]

Generally LGTM, but I feel like the changes aren't c++2a specific (except for uninitialized variables in constexpr functions).

clang/lib/AST/ExprConstant.cpp

4447

[hazohelet]

Address comments from Timm

• Moved test to C++14,20,23 test file from C++20-only one
• NFC stylistic changes

[shafik]

LGTM

clang/docs/ReleaseNotes.rst

 Improvements to Clang's diagnostics
 -----------------------------------
 - Clang constexpr evaluator now prints template arguments when displaying
   template-specialization function calls.
 - Clang contexpr evaluator now displays notes as well as an error when a constructor
   of a base class is not called in the constructor of its derived class.
 - Clang no longer emits ``-Wmissing-variable-declarations`` for variables declared
   with the ``register`` storage class.
+- Clang constexpr evaluator now diagnoses compound assignment operators against
+  uninitialized variables as a read of uninitialized object.
+  (`#51536 <https://github.com/llvm/llvm-project/issues/51536>_`)
 
 Bug Fixes in This Version
 -------------------------
 - Fixed an issue where a class template specialization whose declaration is
   instantiated in one module and whose definition is instantiated in another
   module may end up with members associated with the wrong declaration of the
   class, which can result in miscompiles in some cases.
 - Fix crash on use of a variadic overloaded operator.

clang/lib/AST/ExprConstant.cpp

bool found(APValue &Subobj, QualType SubobjType) {
     case APValue::ComplexFloat:
       // FIXME: Implement complex compound assignment.
       Info.FFDiag(E);
       return false;
     case APValue::LValue:
       return foundPointer(Subobj, SubobjType);
     case APValue::Vector:
       return foundVector(Subobj, SubobjType);
+    case APValue::Indeterminate:
+      Info.FFDiag(E, diag::note_constexpr_access_uninit)
+          << /*read of*/ 0 << /*uninitialized object*/ 1;
+      return false;
     default:
       // FIXME: can this happen?
       Info.FFDiag(E);
       return false;
     }
   }
 
   bool foundVector(APValue &Value, QualType SubobjType) {

clang/test/SemaCXX/constant-expression-cxx2a.cpp

 namespace GH57516 {
 class B{
   virtual constexpr ~B() = 0; // expected-note {{overridden virtual function is here}}
 };
 
 class D : B{}; // expected-error {{deleted function '~D' cannot override a non-deleted function}}
 // expected-note@-1 {{destructor of 'D' is implicitly deleted because base class 'B' has an inaccessible destructor}}
 }
+
+namespace UninitCompoundAssign {
+constexpr int scalar(int a) {
+  int sum;
+  sum += a; // expected-note {{read of uninitialized object}};
+  return 0;
+}
+static_assert(scalar(3)); // expected-error {{constant expression}} \
+                          // expected-note {{in call to 'scalar(3)'}}
+
+constexpr int array(int a) {
+  int arr[3];
+  arr[1] += a; // expected-note {{read of uninitialized object}};
+  return 0;
+}
+static_assert(array(3)); // expected-error {{constant expression}} \
+                         // expected-note {{in call to 'array(3)'}}
+
+struct Foo {
+  int val;
+  constexpr Foo() {}
+};
+constexpr int field(int a) {
+  Foo f;
+  f.val += a; // expected-note {{read of uninitialized object}};
+  return 0;
+}
+static_assert(field(3)); // expected-error {{constant expression}} \
+                         // expected-note {{in call to 'field(3)'}}
+}