[Documentation] improved documentation of diagnostic messages by explaining thier syntax and test of clang by telling which subobject is uninitialized

[probinson]

You are combining documentation of the syntax for defining diagnostics, and changes to the content of certain diagnostics. The LLVM project wants to see one topic per patch, so these things need to be done separately.

Also, the documentation probably does not want to live in one of the many .td files that define diagnostics. It wants to go somewhere generic, and I'm not sure what a good place would be.

[olista01]

There is existing documentation of the diagnostics system here, which you could extend if something is still unclear or incomplete:

• clang/docs/InternalsManual.rst
• https://clang.llvm.org/docs/InternalsManual.html#the-diagnostics-subsystem

[simideveloper]

Oh sorry, I was unaware of the existing documentation.
thank you for your time, sir.

clang/include/clang/Basic/DiagnosticASTKinds.td

 //==--- DiagnosticASTKinds.td - libast diagnostics ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+//----------------understanding syntax of diagnostics messages--------===//
+//keyword after def represents symbolic constant for that diagnostics 
+//for %select{}num  The select operator uses num to select one of the alternatives inside the braces, which are separated by |. 
+//If you pass 0 as parameter , it will substitute the 0th alternative, which is the empty string; if you pass I, it will substitute the Ith alternative
+//%num is a placeholder for a parameter passed to the diagnostic engine where num can be 0 for first argument 1 for second argument and so on
+//===--------------------------------------------------------------------===//
 let Component = "AST" in {
 
 // Constant expression diagnostics. These (and their users) belong in Sema.
 def note_expr_divide_by_zero : Note<"division by zero">;
 def note_constexpr_invalid_cast : Note<
   "%select{reinterpret_cast|dynamic_cast|%select{this conversion|cast that"
   " performs the conversions of a reinterpret_cast}1|cast from %1}0"
   " is not allowed in a constant expression"

clang/lib/AST/Interp/Interp.cpp

 //===------- Interp.cpp - Interpreter for the constexpr VM ------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 

 static bool CheckArrayInitialized(InterpState &S, CodePtr OpPC,
                                   const Pointer &BasePtr,
                                   const ConstantArrayType *CAT) {
   bool Result = true;
   size_t NumElems = CAT->getSize().getZExtValue();
   QualType ElemType = CAT->getElementType();
 
   if (isa<RecordType>(ElemType.getTypePtr())) {
-    const Record *R = BasePtr.getElemRecord();
     for (size_t I = 0; I != NumElems; ++I) {
       Pointer ElemPtr = BasePtr.atIndex(I).narrow();
       Result &= CheckFieldsInitialized(S, OpPC, ElemPtr, R);
     }
   } else if (auto *ElemCAT = dyn_cast<ConstantArrayType>(ElemType)) {
     for (size_t I = 0; I != NumElems; ++I) {
       Pointer ElemPtr = BasePtr.atIndex(I).narrow();
       Result &= CheckArrayInitialized(S, OpPC, ElemPtr, ElemCAT);

clang/test/AST/Interp/cxx20.cpp

 namespace UninitializedFields {
   class A {
   public:
     int a; // expected-note 2{{subobject declared here}} \
            // ref-note 2{{subobject declared here}}
     constexpr A() {}
   };
   constexpr A a; // expected-error {{must be initialized by a constant expression}} \
-                 // expected-note {{subobject of type 'int' is not initialized}} \
+                 // expected-note {{subobject  a is not initialized}} \
                  // ref-error {{must be initialized by a constant expression}} \
-                 // ref-note {{subobject of type 'int' is not initialized}}
+                 // ref-note {{subobject a is not initialized}}
 
 
   class Base {
   public:
     bool b;
     int a; // expected-note {{subobject declared here}} \
            // ref-note {{subobject declared here}}
     constexpr Base() : b(true) {}
   };
 
   class Derived : public Base {
   public:
     constexpr Derived() : Base() {}   };
 
   constexpr Derived D; // expected-error {{must be initialized by a constant expression}} \
-                       // expected-note {{subobject of type 'int' is not initialized}} \
+                       // expected-note {{subobject a is not initialized}} \
                        // ref-error {{must be initialized by a constant expression}} \
-                       // ref-note {{subobject of type 'int' is not initialized}}
+                       // ref-note {{subobject a is not initialized}}
 
   class C2 {
   public:
     A a;
     constexpr C2() {}   };
   constexpr C2 c2; // expected-error {{must be initialized by a constant expression}} \
-                   // expected-note {{subobject of type 'int' is not initialized}} \
+                   // expected-note {{subobject a is not initialized}} \
                    // ref-error {{must be initialized by a constant expression}} \
-                   // ref-note {{subobject of type 'int' is not initialized}}
+                   // ref-note {{subobject a is not initialized}}
 
 
   // FIXME: These two are currently disabled because the array fields
   //   cannot be initialized.
 #if 0
   class C3 {
   public:
     A a[2];
     constexpr C3() {}
   };
   constexpr C3 c3; // expected-error {{must be initialized by a constant expression}} \
-                   // expected-note {{subobject of type 'int' is not initialized}} \
+                   // expected-note {{subobject a is not initialized}} \
                    // ref-error {{must be initialized by a constant expression}} \
-                   // ref-note {{subobject of type 'int' is not initialized}}
+                   // ref-note {{subobject a is not initialized}}
 
   class C4 {
   public:
     bool B[2][3]; // expected-note {{subobject declared here}} \
                   // ref-note {{subobject declared here}}
     constexpr C4(){}
   };
   constexpr C4 c4; // expected-error {{must be initialized by a constant expression}} \
-                   // expected-note {{subobject of type 'bool' is not initialized}} \
+                   // expected-note {{subobject B is not initialized}} \
                    // ref-error {{must be initialized by a constant expression}} \
-                   // ref-note {{subobject of type 'bool' is not initialized}}
+                   // ref-note {{subobject B is not initialized}}
 #endif
 };
 
 namespace ConstThis {
   class Foo {
     const int T = 12; // expected-note {{declared const here}} \
                       // ref-note {{declared const here}}
     int a;

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p4.cpp

union {
       };
     };
     constexpr V() : x(0) {}
   };
 
   // The constructor is still 'constexpr' here, but the result is not intended
   // to be a constant expression. The standard is not clear on how this should
   // work.
-  constexpr V<int> v; // expected-error {{constant expression}} expected-note {{subobject of type 'int' is not initialized}}
+  constexpr V<int> v; // expected-error {{constant expression}} expected-note {{subobject  y is not initialized}}
 
   constexpr int k = V<int>().x; // FIXME: ok?
 }

clang/test/SemaCXX/attr-require-constant-initialization.cpp

 // initializer for the object;
 
 void test_basic_start_static_2_2(void) {
 #if __cplusplus < 201103L
   ATTR static PODType pod;
 #else
   ATTR static PODType pod; // expected-error {{variable does not have a constant initializer}}
 // expected-note@-1 {{required by 'require_constant_initialization' attribute here}}
-// expected-note-re@-2 {{{{non-constexpr constructor|subobject of type 'int' is not initialized}}}}
+// expected-note-re@-2 {{{{non-constexpr constructor|subobject value and value2 is not initialized}}}}
 #endif
   ATTR static PODType pot2 = {ReturnInt()}; // expected-error {{variable does not have a constant initializer}}
                                             // expected-note@-1 {{required by 'require_constant_initialization' attribute here}}
 #if __cplusplus >= 201103L
 // expected-note@-3 {{non-constexpr function 'ReturnInt' cannot be used in a constant expression}}
 #else
 // expected-note@-5 {{subexpression not valid in a constant expression}}
 #endif
#if __cplusplus >= 201402L
   ATTR static const NonLit non_lit;
   ATTR static const NonLit non_lit_list_init;
   ATTR static const NonLit non_lit_copy_init;
 #endif
 };
 PODType TT2::pod_noinit; // expected-note 0+ {{declared here}}
 #if __cplusplus >= 201103L
 // expected-error@-2 {{variable does not have a constant initializer}}
-// expected-note-re@-3 {{{{non-constexpr constructor|subobject of type 'int' is not initialized}}}}
+// expected-note-re@-3 {{{{non-constexpr constructor|subobject value and value2 is not initialized}}}}
 #endif
 PODType TT2::pod_copy_init(TT2::pod_noinit); // expected-error {{variable does not have a constant initializer}}
 #if __cplusplus >= 201103L
 // expected-note@-2 {{read of non-constexpr variable 'pod_noinit' is not allowed in a constant expression}}
 // expected-note@-3 {{in call to 'PODType(pod_noinit)'}}
 #else
 // expected-note@-5 {{subexpression not valid in a constant expression}}
 #endif

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

constexpr int change_member_indirectly() {
     return b.a.arr[2];
   }
   static_assert(change_member_indirectly() == 4);
   constexpr B return_uninit() {
     B b = {.b = 1};
     b.a.x = 2;
     return b;
   }
-  constexpr B uninit = return_uninit(); // expected-error {{constant expression}} expected-note {{subobject of type 'int' is not initialized}}
+  constexpr B uninit = return_uninit(); // expected-error {{constant expression}} expected-note {{subobject  arr and p or q  is not initialized}}
   static_assert(return_uninit().a.x == 2);
   constexpr A return_uninit_struct() {
     B b = {.b = 1};
     b.a.x = 2;
-    return b.a; // expected-note {{in call to 'A(b.a)'}} expected-note {{subobject of type 'int' is not initialized}}
+    return b.a; // expected-note {{in call to 'A(b.a)'}} expected-note {{subobject arr and p or q is not initialized}}
   }
   // Note that this is rejected even though return_uninit() is accepted, and
   // return_uninit() copies the same stuff wrapped in a union.
   //
   // Copying a B involves copying the object representation of the union, but
   // copying an A invokes a copy constructor that copies the object
   // elementwise, and reading from b.a.y is undefined.
   static_assert(return_uninit_struct().x == 2); // expected-error {{constant expression}} expected-note {{in call}}
namespace Uninit {
 
   struct X {
     int n; // expected-note {{declared here}}
     constexpr X(bool init) {
       if (init) n = 123;
     }
   };
   constinit X x1(true);
-  constinit X x2(false); // expected-error {{constant initializer}} expected-note {{constinit}} expected-note {{subobject of type 'int' is not initialized}}
+  constinit X x2(false); // expected-error {{constant initializer}} expected-note {{constinit}} expected-note {{subobject n is not initialized}}
 
   struct Y {
     struct Z { int n; }; // expected-note {{here}}
     Z z1;
     Z z2;
     Z z3;
     // OK: the lifetime of z1 (and its members) start before the initializer of
     // z2 runs.
     constexpr Y() : z2{ (z1.n = 1, z1.n + 1) } { z3.n = 3; }
     // Not OK: z3 is not in its lifetime when the initializer of z2 runs.
     constexpr Y(int) : z2{
       (z3.n = 1, // expected-note {{assignment to object outside its lifetime}}
        z3.n + 1) // expected-warning {{uninitialized}}
     } { z1.n = 3; }
     constexpr Y(int, int) : z2{} {}
   };
   // FIXME: This is working around clang not implementing DR2026. With that
   // fixed, we should be able to test this without the injected copy.
-  constexpr Y copy(Y y) { return y; } // expected-note {{in call to 'Y(y)'}} expected-note {{subobject of type 'int' is not initialized}}
+  constexpr Y copy(Y y) { return y; } // expected-note {{in call to 'Y(y)'}} expected-note {{subobject z1.n is not initialized}}
   constexpr Y y1 = copy(Y());
   static_assert(y1.z1.n == 1 && y1.z2.n == 2 && y1.z3.n == 3);
 
   constexpr Y y2 = copy(Y(0)); // expected-error {{constant expression}} expected-note {{in call}}
 
   static_assert(Y(0,0).z2.n == 0);
   static_assert(Y(0,0).z1.n == 0); // expected-error {{constant expression}} expected-note {{read of uninitialized object}}
   static_assert(Y(0,0).z3.n == 0); // expected-error {{constant expression}} expected-note {{read of uninitialized object}}

clang/test/SemaCXX/cxx2a-consteval.cpp

 
 namespace NamespaceScopeConsteval {
 struct S {
   int Val; // expected-note {{subobject declared here}}
   consteval S() {}
 };
 
 S s1; // expected-error {{call to consteval function 'NamespaceScopeConsteval::S::S' is not a constant expression}} \
-         expected-note {{subobject of type 'int' is not initialized}}
+         expected-note {{subobject Val is not initialized}}
 
 template <typename Ty>
 struct T {
   Ty Val; // expected-note {{subobject declared here}}
   consteval T() {}
 };
 
 T<int> t; // expected-error {{call to consteval function 'NamespaceScopeConsteval::T<int>::T' is not a constant expression}} \
-             expected-note {{subobject of type 'int' is not initialized}}
+             expected-note {{subobject Val is not initialized}}
 
 } // namespace NamespaceScopeConsteval
 
 namespace Issue54578 {
 // We expect the user-defined literal to be resovled entirely at compile time
 // despite being instantiated through a template.
 inline consteval unsigned char operator""_UC(const unsigned long long n) {
   return static_cast<unsigned char>(n);