[Diagnostic] printing name of uninitialized subobject instead of its type

[simideveloper]

Summary

here I am trying to solve the issue
https://github.com/llvm/llvm-project/issues/58601
by printing an uninitialized subobject name instead of its type

[junaire]

I don't have enough context on this patch, but obviously, there's something you can improve.

1. You need to add a test, maybe somewhere in clang/test/Sema/
2. Please make a detailed summary of your patch so reviewers know what's going on here. You can also link the GitHub issue.

clang/include/clang/Basic/DiagnosticASTKinds.td

9

Why delete these? Looks like unrelated changes.

[junaire]

BTW, does this patch overlaps with https://reviews.llvm.org/D146358?

[simideveloper]

I am an outreachy applicant and working on this issue for the past some weeks for my contribution on the community page till that time this issue was listed on the introductory issues list on the outreachy page I thought this issue is still open but was not aware of someone working sorry it's my bad if it's already solved.

clang/include/clang/Basic/DiagnosticASTKinds.td

9

I submitted another review for documentation on diagnostic in which I added these comments but it was not relevant so I removed it

[simideveloper]

can you please tell me if this issue is closed or I can work on making the changes you recommended?

[tbaeder]

Yeah I think https://reviews.llvm.org/D146358 was first and this patch doesn't add much over it, correct me if I'm wrong.

[aaron.ballman]

(Btw, if you no longer plan to work on a patch, it's considered good form to "abandon" the patch in Phabricator. You can do this by clicking the Add Action drop-down menu and selecting Abandon Changes.)

[simideveloper]

but I think this patch https://reviews.llvm.org/D146358 has not been accepted yet so you should give me a chance.

[aaron.ballman]

In D146867#4224567, @simideveloper wrote:

but I think this patch https://reviews.llvm.org/D146358 has not been accepted yet so you should give me a chance.

What we want to avoid is having reviewers review multiple patches trying to solve the same problem. At the end of the day, we are less concerned about *who* makes changes and are more concerned that the changes are properly reviewed, are correct, etc. So you should work with the other patch author to figure out who is doing what work or whether they need help collaborating on their patch.

[simideveloper]

okk thankyou 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"
def note_constexpr_not_static : Note<
   "of the enclosing function; add 'static' to give it a constant address">;
 def note_constexpr_dynamic_alloc : Note<
   "%select{pointer|reference}0 to %select{|subobject of }1"
   "heap-allocated object is not a constant expression">;
 def note_consteval_address_accessible : Note<
   "%select{pointer|reference}0 to a consteval declaration "
   "is not a constant expression">;
 def note_constexpr_uninitialized : Note<
-  "%select{|sub}0object of type %1 is not initialized">;
+  "%select{|sub}0object  %1 is not initialized">;
 def note_constexpr_static_local : Note<
   "control flows through the definition of a %select{static|thread_local}0 variable">;
 def note_constexpr_subobject_declared_here : Note<
   "subobject declared here">;
 def note_constexpr_array_index : Note<"cannot refer to element %0 of "
   "%select{array of %2 element%plural{1:|:s}2|non-array object}1 "
   "in a constant expression">;
 def note_constexpr_float_arithmetic : Note<

clang/lib/AST/ExprConstant.cpp

 //===--- ExprConstant.cpp - Expression Constant Evaluator -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //

 /// initializsed by a constant expression.
 using CheckedTemporaries =
     llvm::SmallPtrSet<const MaterializeTemporaryExpr *, 8>;
 
 static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
                                   EvalInfo &Info, SourceLocation DiagLoc,
                                   QualType Type, const APValue &Value,
                                   ConstantExprKind Kind,
-                                  SourceLocation SubobjectLoc,
+                                  const FieldDecl* SubobjectDecl,
                                   CheckedTemporaries &CheckedTemps);
 
 /// Check that this reference or pointer core constant expression is a valid
 /// value for an address or reference constant expression. Return true if we
 /// can fold this expression, whether or not it's a constant expression.
 static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
                                           QualType Type, const LValue &LVal,
                                           ConstantExprKind Kind,
if (CheckedTemps.insert(MTE).second) {
             << TempType;
         return false;
       }
 
       APValue *V = MTE->getOrCreateValue(false);
       assert(V && "evasluation result refers to uninitialised temporary");
       if (!CheckEvaluationResult(CheckEvaluationResultKind::ConstantExpression,
                                  Info, MTE->getExprLoc(), TempType, *V,
-                                 Kind, SourceLocation(), CheckedTemps))
+                                 Kind,  /*SubobjectDecl=*/nullptr, CheckedTemps))
         return false;
     }
   }
 
   // Allow address constant expressions to be past-the-end pointers. This is
   // an extension: the standard requires them to point to an object.
   if (!IsReferenceType)
     return true;
else
     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
   return false;
 }
 
 static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
                                   EvalInfo &Info, SourceLocation DiagLoc,
                                   QualType Type, const APValue &Value,
                                   ConstantExprKind Kind,
-                                  SourceLocation SubobjectLoc,
+                                  const FieldDecl* SubobjectDecl,
                                   CheckedTemporaries &CheckedTemps) {
-  if (!Value.hasValue()) {
+  if ((!Value.hasValue())&& SubobjectDecl!=nullptr) {
     Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized)
-      << true << Type;
-    if (SubobjectLoc.isValid())
-      Info.Note(SubobjectLoc, diag::note_constexpr_subobject_declared_here);
+      << true << SubobjectDecl->getName();
+    if (SubobjectDecl->getLocation().isValid())
+      Info.Note(SubobjectDecl->getLocation(), diag::note_constexpr_subobject_declared_here);
     return false;
   }
 
   // We allow _Atomic(T) to be initialized from anything that T can be
   // initialized from.
   if (const AtomicType *AT = Type->getAs<AtomicType>())
     Type = AT->getValueType();
 
   // Core issue 1454: For a literal constant expression of array or class type,
   // each subobject of its value shall have been initialized by a constant
   // expression.
   if (Value.isArray()) {
     QualType EltTy = Type->castAsArrayTypeUnsafe()->getElementType();
     for (unsigned I = 0, N = Value.getArrayInitializedElts(); I != N; ++I) {
       if (!CheckEvaluationResult(CERK, Info, DiagLoc, EltTy,
-                                 Value.getArrayInitializedElt(I), Kind,
-                                 SubobjectLoc, CheckedTemps))
+                                 Value.getArrayInitializedElt(I), Kind,SubobjectDecl
+                                 , CheckedTemps))
         return false;
     }
     if (!Value.hasArrayFiller())
       return true;
     return CheckEvaluationResult(CERK, Info, DiagLoc, EltTy,
-                                 Value.getArrayFiller(), Kind, SubobjectLoc,
+                                 Value.getArrayFiller(), Kind, SubobjectDecl,
                                  CheckedTemps);
   }
   if (Value.isUnion() && Value.getUnionField()) {
     return CheckEvaluationResult(
         CERK, Info, DiagLoc, Value.getUnionField()->getType(),
-        Value.getUnionValue(), Kind, Value.getUnionField()->getLocation(),
+        Value.getUnionValue(), Kind, Value.getUnionField(),
         CheckedTemps);
   }
   if (Value.isStruct()) {
     RecordDecl *RD = Type->castAs<RecordType>()->getDecl();
     if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
       unsigned BaseIndex = 0;
       for (const CXXBaseSpecifier &BS : CD->bases()) {
         if (!CheckEvaluationResult(CERK, Info, DiagLoc, BS.getType(),
                                    Value.getStructBase(BaseIndex), Kind,
-                                   BS.getBeginLoc(), CheckedTemps))
+                                    /*SubobjectDecl=*/nullptr, CheckedTemps))
           return false;
         ++BaseIndex;
       }
     }
     for (const auto *I : RD->fields()) {
       if (I->isUnnamedBitfield())
         continue;
 
       if (!CheckEvaluationResult(CERK, Info, DiagLoc, I->getType(),
                                  Value.getStructField(I->getFieldIndex()),
-                                 Kind, I->getLocation(), CheckedTemps))
+                                 Kind, I, CheckedTemps))
         return false;
     }
   }
 
   if (Value.isLValue() &&
       CERK == CheckEvaluationResultKind::ConstantExpression) {
     LValue LVal;
     LVal.setFrom(Info.Ctx, Value);
static bool CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc,
                                     ConstantExprKind Kind) {
   // Nothing to check for a constant expression of type 'cv void'.
   if (Type->isVoidType())
     return true;
 
   CheckedTemporaries CheckedTemps;
   return CheckEvaluationResult(CheckEvaluationResultKind::ConstantExpression,
                                Info, DiagLoc, Type, Value, Kind,
-                               SourceLocation(), CheckedTemps);
+                               nullptr, CheckedTemps);
 }
 
 /// Check that this evaluated value is fully-initialized and can be loaded by
 /// an lvalue-to-rvalue conversion.
 static bool CheckFullyInitialized(EvalInfo &Info, SourceLocation DiagLoc,
                                   QualType Type, const APValue &Value) {
   CheckedTemporaries CheckedTemps;
   return CheckEvaluationResult(
       CheckEvaluationResultKind::FullyInitialized, Info, DiagLoc, Type, Value,
-      ConstantExprKind::Normal, SourceLocation(), CheckedTemps);
+      ConstantExprKind::Normal,nullptr, CheckedTemps);
 }
 
 /// Enforce C++2a [expr.const]/4.17, which disallows new-expressions unless
 /// "the allocated storage is deallocated within the evaluation".
 static bool CheckMemoryLeaks(EvalInfo &Info) {
   if (!Info.HeapAllocs.empty()) {
     // We can still fold to a constant despite a compile-time memory leak,
     // so long as the heap allocation isn't referenced in the result (we check

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
 //
 //===----------------------------------------------------------------------===//
 
if (!MD->isPure())
     return true;
   const SourceInfo &E = S.Current->getSource(OpPC);
   S.FFDiag(E, diag::note_constexpr_pure_virtual_call, 1) << MD;
   S.Note(MD->getLocation(), diag::note_declared_at);
   return false;
 }
 
 static void DiagnoseUninitializedSubobject(InterpState &S, const SourceInfo &SI,
-                                           QualType SubObjType,
+                                           StringRef SubObjName,
                                            SourceLocation SubObjLoc) {
-  S.FFDiag(SI, diag::note_constexpr_uninitialized) << true << SubObjType;
+  S.FFDiag(SI, diag::note_constexpr_uninitialized) << true << SubObjName;
   if (SubObjLoc.isValid())
     S.Note(SubObjLoc, diag::note_constexpr_subobject_declared_here);
 }
 
 static bool CheckFieldsInitialized(InterpState &S, CodePtr OpPC,
                                    const Pointer &BasePtr, const Record *R);
 
 static bool CheckArrayInitialized(InterpState &S, CodePtr OpPC,
static bool CheckArrayInitialized(InterpState &S, CodePtr OpPC,
   } 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);
     }
   } else {
     for (size_t I = 0; I != NumElems; ++I) {
       if (!BasePtr.atIndex(I).isInitialized()) {
-        DiagnoseUninitializedSubobject(S, S.Current->getSource(OpPC), ElemType,
+        DiagnoseUninitializedSubobject(S, S.Current->getSource(OpPC), BasePtr.getElemRecord()->getName(),
                                        BasePtr.getFieldDesc()->getLocation());
         Result = false;
       }
     }
   }
 
   return Result;
 }
for (const Record::Field &F : R->fields()) {
     if (FieldType->isRecordType()) {
       Result &= CheckFieldsInitialized(S, OpPC, FieldPtr, FieldPtr.getRecord());
     } else if (FieldType->isArrayType()) {
       const auto *CAT =
           cast<ConstantArrayType>(FieldType->getAsArrayTypeUnsafe());
       Result &= CheckArrayInitialized(S, OpPC, FieldPtr, CAT);
     } else if (!FieldPtr.isInitialized()) {
       DiagnoseUninitializedSubobject(S, S.Current->getSource(OpPC),
-                                     F.Decl->getType(), F.Decl->getLocation());
+                                     F.Decl->getName(), F.Decl->getLocation());
       Result = false;
     }
   }
 
   // Check Fields in all bases
   for (const Record::Base &B : R->bases()) {
     Pointer P = Pointer(BasePtr.block(), B.Offset);
     Result &= CheckFieldsInitialized(S, OpPC, P, B.R);