[clang][AST] Print name instead of type when diagnosing uninitialized subobject in constexpr variables

[hazohelet]

Summary

This patch improves the diagnostic on uninitialized subobjects in constexpr variables by modifying the diagnostic message to display the subobject's name instead of its type.

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

[shafik]

Thank you for submitting this fix.

clang/lib/AST/ExprConstant.cpp

2270

To conform to clang-tidy bugprone-argument-comment format

2397

same here.

2442

Also here

2454

and here

clang/lib/AST/Interp/Interp.cpp

373

Do we need to check that SubObjDecl is not nullptr ever?

[shafik]

clang/lib/AST/Interp/Interp.cpp

373

If we are sure it can never be nullptr then we should assert(SubObjDecl)

[tbaeder]

"subobject named 'foo'" sounds a bit weird to me, I'd expect just "subobject 'foo'", but that's just a suggestion and I'll wait for a native spearker to chime in on this.

clang/lib/AST/Interp/Interp.cpp

373

Should never be null here.

[hazohelet]

Address comments from @shafik and @tbaeder

[tbaeder]

Pinging @cjdb and @aaron.ballman for some feedback on the wording

[cjdb]

In D146358#4204412, @tbaeder wrote:

"subobject named 'foo'" sounds a bit weird to me, I'd expect just "subobject 'foo'", but that's just a suggestion and I'll wait for a native spearker to chime in on this.

My expert brain likes subobject of type 'T', but it's very wordy, and potentially not useful additional info. I'm partial to subobject 'T' due to it being the thing we're more likely to say in conversation (e.g. "that int isn't initialised"). I've also put out a mini-survey on the #include <C++> Discord server, and will update in a few hours.

[hazohelet]

In D146358#4227938, @cjdb wrote:

In D146358#4204412, @tbaeder wrote:

"subobject named 'foo'" sounds a bit weird to me, I'd expect just "subobject 'foo'", but that's just a suggestion and I'll wait for a native spearker to chime in on this.

My expert brain likes subobject of type 'T', but it's very wordy, and potentially not useful additional info. I'm partial to subobject 'T' due to it being the thing we're more likely to say in conversation (e.g. "that int isn't initialised"). I've also put out a mini-survey on the #include <C++> Discord server, and will update in a few hours.

Hi, @cjdb thanks for your feedback and the mini-survey.
The objective of this patch is to print the subobject's name instead of its type when it is not initialized in constexpr variable initializations. Thus, I think it would be appropriate to add some more options to the survey like "subobject named 'foo' is not initialized" and "subobject 'foo' is not initialized" when the code looks like the following:

template <typename T>
struct F {
	T foo;
	constexpr F(){}
};
constexpr F <int>f;

[cjdb]

In D146358#4229120, @hazohelet wrote:

In D146358#4227938, @cjdb wrote:

In D146358#4204412, @tbaeder wrote:

"subobject named 'foo'" sounds a bit weird to me, I'd expect just "subobject 'foo'", but that's just a suggestion and I'll wait for a native spearker to chime in on this.

My expert brain likes subobject of type 'T', but it's very wordy, and potentially not useful additional info. I'm partial to subobject 'T' due to it being the thing we're more likely to say in conversation (e.g. "that int isn't initialised"). I've also put out a mini-survey on the #include <C++> Discord server, and will update in a few hours.

Hi, @cjdb thanks for your feedback and the mini-survey.
The objective of this patch is to print the subobject's name instead of its type when it is not initialized in constexpr variable initializations. Thus, I think it would be appropriate to add some more options to the survey like "subobject named 'foo' is not initialized" and "subobject 'foo' is not initialized" when the code looks like the following:

template <typename T>
struct F {
	T foo;
	constexpr F(){}
};
constexpr F <int>f;

Ah, in that case, subobject 'foo' is better than subobject named 'foo' to me.

[simideveloper]

hey, I was working on the same issue so can we collaborate on this issue?

[hazohelet]

In D146358#4230122, @simideveloper wrote:

hey, I was working on the same issue so can we collaborate on this issue?

@simideveloper Thanks for your interest in collaborating on this issue, and sorry if I discouraged you from contributing by working on the same problem.
I assume this patch is in the its final stage, awaiting feedback on wording. However, there's more room for improvement around the uninitialized subobject diagnostics of clang, and your experience working on this issue could be helpful in resolving those issues.
One example of further improvement:

struct Type1 { int val; }; // note emitted

struct Derived {
  Type1 val; // we could note on this as well
  constexpr Derived(){}
};

constexpr Derived D;

Link: https://godbolt.org/z/v3rhz88aM
I am open to future collaboration opportunities as well. Happy hacking!

[simideveloper]

ok, no problem and thanks for those further issues @hazohelet

[aaron.ballman]

Thank you for working on this! The changes should also come with a release note in clang/docs/ReleaseNotes.rst to note the improvement.

clang/lib/AST/ExprConstant.cpp

2356–2360

Hmm, this breaks one of the contracts of our constexpr evaluation engine, doesn't it? My understanding is that if constexpr evaluation fails, we will have emitted a note diagnostic for why it failed. But if the caller doesn't pass a nonnull SubobjectDecl, we'll return false but we won't issue a diagnostic.

I'm surprised no tests lost notes as a result of this change, that suggests we're missing test coverage for the cases where nullptr is passed in explicitly to this function.

[hazohelet]

@aaron.ballman
Thanks for the review! I'll add a release note.

clang/lib/AST/ExprConstant.cpp

2356–2360

Yeah, I was looking into when SubobjectDecl can be null here. I asserted the non-nullness of SubobjectDecl before and found that there exists two lines of code (https://github.com/llvm/llvm-project/blob/22a3f974d35da89247c0396594f2e4cd592742eb/clang/test/SemaCXX/attr-weak.cpp#L49 and https://github.com/llvm/llvm-project/blob/abf4a8cb15d4faf04ee0da14e37d7349d3bde9a1/clang/test/CodeGenCXX/weak-external.cpp#L97) in the test codes that nulls here.
It seems they are doing the same thing, doing comparison against a pointer to a [[gnu::weak]] member. A simple reproducing code is here: https://godbolt.org/z/qn997n85n
As you can see from the compiler explorer, there's no note emitted here before the patch.
I inserted some printf into the code before this patch and confirmed Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized) << true << Type was actually called when compiling the reproducing code and that somehow it is ignored. FWIW, SubobjectLoc.isValid() was false here.

[hazohelet]

Added release note

[aaron.ballman]

clang/lib/AST/ExprConstant.cpp

2356–2360

It seems they are doing the same thing, doing comparison against a pointer to a [[gnu::weak]] member. A simple reproducing code is here: https://godbolt.org/z/qn997n85n
As you can see from the compiler explorer, there's no note emitted here before the patch.

I see a note generated there:

<source>:4:41: note: comparison against pointer to weak member 'Weak::weak_method' can only be performed at runtime
constexpr bool val = &Weak::weak_method != nullptr;
                                        ^

The situations I'm concerned about are the changes to ExprConstant.cpp:2270 or line 2399 and so on.

[tbaeder]

clang/lib/AST/ExprConstant.cpp

2356–2360

The FFDiag call can just stay as it was, right? And then only the Info.Note call needs to be conditional for whether we have a SubobjectDecl.

[hazohelet]

clang/lib/AST/ExprConstant.cpp

2356–2360

In my understanding, the concern is that there could be note loss when Value.hasValue() evaluates to false and at the same time SubobjectDecl is nullptr explicitly passed in this change.
[[gnu::weak]] member pointer comparison is the only example of this happening in the clang test codes where Subobject is nullptr passed at ExprConstant.cpp:2454 in CheckFullyInitialized. In this case the "uninitialized subobject" note was not displayed before this patch as well because there is another note issued elsewhere. Thus, the note loss does not happen.

BTW, I checked where the [[gnu::weak]] note is issued and I think there might be a mistake in the return statements. The return true should be return false because the constexpr evaluator fails to evaluate the expression, right? Correct me if I am wrong. Here's the reference:
https://github.com/llvm/llvm-project/blob/e58a49300e757ff61142f6abd227bd1437c1cf87/clang/lib/AST/ExprConstant.cpp#L13140-L13151

If we change them to false, CheckFullyInitialized will not be called in this scenario, and we will have no test cases where SubobjectDecl is nullptr and at the same time Value.hasValue() is false. I am unsure whether this is due to the lack of test coverage or it is guaranteed that this condition does not hold here.

The FFDiag call can just stay as it was, right? And then only the Info.Note call needs to be conditional for whether we have a SubobjectDecl.

If SubobjectDecl is null, it would cause segfault when the FFDiag note is displayed, I think.

The best way I can think of would be to assert(SubobjectDecl) here, but I am still struggling and would like to ask for comments.

[tbaeder]

So, if I understand the code correctly, we call CheckEvaluationResult with SubObjectDecl=nullptr when we're not checking an actual field but just an array/record, so we can't run into this problem anyway, so the assert seems fine.

I don't fully understand the problem with the gnu::weak stuff, in any case, adding it to this patch seems wrong. https://godbolt.org/z/qn997n85n does emit a note, but it's not the one this patch is about, so is that even relevant?

[hazohelet]

In D146358#4268327, @tbaeder wrote:

So, if I understand the code correctly, we call CheckEvaluationResult with SubObjectDecl=nullptr when we're not checking an actual field but just an array/record, so we can't run into this problem anyway, so the assert seems fine.

I don't fully understand the problem with the gnu::weak stuff, in any case, adding it to this patch seems wrong. https://godbolt.org/z/qn997n85n does emit a note, but it's not the one this patch is about, so is that even relevant?

Thanks. I opened another differential for the gnu::weak stuff (D148419).
If my understanding is correct, Info.FFDiag displays only the note of its first call and discard the notes after it. So, the uninitialized-note is not displayed.
You can confirm this by deleting only the FFDiag call (https://github.com/llvm/llvm-project/blob/6f7e5c0f1ac6cc3349a2e1479ac4208465b272c6/clang/lib/AST/ExprConstant.cpp#L13143-L13144) from the clang trunk and compile my godbolt code to see the note (note: subobject of type 'const bool' is not initialized)
Although the return true says the [[gnu::weak]] member pointer comparison is valid, constexpr engine considers the constant initialization has failed if there is note emitted during the initializer evaluation(https://github.com/llvm/llvm-project/blob/6f7e5c0f1ac6cc3349a2e1479ac4208465b272c6/clang/lib/AST/Decl.cpp#L2591-L2592) and it's why [[gnu::weak]] comparison note is actually emitted in spite of the wrong signal about the validness of the expression.

[hazohelet]

Remove gnu::weak diff

[tbaeder]

@aaron.ballman Are you OK with the approach taken here?

[hazohelet]

Ping

[hazohelet]

Rebase and Ping

[aaron.ballman]

LGTM! Did you end up requesting commit access? If not, now is probably a good time: https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access

clang/lib/AST/ExprConstant.cpp

2356–2360

In my understanding, the concern is that there could be note loss when Value.hasValue() evaluates to false and at the same time SubobjectDecl is nullptr explicitly passed in this change.

Correct.

BTW, I checked where the [[gnu::weak]] note is issued and I think there might be a mistake in the return statements. The return true should be return false because the constexpr evaluator fails to evaluate the expression, right? Correct me if I am wrong. Here's the reference:

https://github.com/llvm/llvm-project/blob/e58a49300e757ff61142f6abd227bd1437c1cf87/clang/lib/AST/ExprConstant.cpp#L13140-L13151

Agreed, that's a bug, good catch and thank you for the fix!

The best way I can think of would be to assert(SubobjectDecl) here, but I am still struggling and would like to ask for comments.

That's the approach I would try initially as well -- unfortunately, precommit CI is currently broken due to configuration issues, so we might only learn about issue post-commit.

[hazohelet]

In D146358#4343281, @aaron.ballman wrote:

LGTM! Did you end up requesting commit access? If not, now is probably a good time: https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access

Thanks, I have commit access now, so I'll land this patch myself

[erichkeane]

Our downstream discovered that this causes a regression when compiling utility with ast-dump. I've put up a minimal reproducer: https://godbolt.org/z/oaezas7Ws

@hazohelet : Will you be able to look into this soon?

[erichkeane]

Slightly smaller reproducer: https://godbolt.org/z/W5zjrKaz9

[hazohelet]

In D146358#4350810, @erichkeane wrote:

Our downstream discovered that this causes a regression when compiling utility with ast-dump. I've put up a minimal reproducer: https://godbolt.org/z/oaezas7Ws

@hazohelet : Will you be able to look into this soon?

Thanks for the report and the reproducer.
I cannot take sufficient time for about 36 hours, but I'll be able to investigate it after that.

[erichkeane]

In D146358#4351787, @hazohelet wrote:

In D146358#4350810, @erichkeane wrote:

Our downstream discovered that this causes a regression when compiling utility with ast-dump. I've put up a minimal reproducer: https://godbolt.org/z/oaezas7Ws

@hazohelet : Will you be able to look into this soon?

Thanks for the report and the reproducer.
I cannot take sufficient time for about 36 hours, but I'll be able to investigate it after that.

That is long enough away that I unfortunately have to revert (see 34e49d3e85a6dd03856af0fb4b7f8d8ae1f4f06a). Please note that in the LLVM project reverts are common/frequent (we have a policy of 'revert often'), and should not be taken negatively! Please feel free to re-submit this patch with a fix/the test provided, and we'll re-review promptly!

[hazohelet]

In D146358#4352792, @erichkeane wrote:

In D146358#4351787, @hazohelet wrote:

In D146358#4350810, @erichkeane wrote:

Our downstream discovered that this causes a regression when compiling utility with ast-dump. I've put up a minimal reproducer: https://godbolt.org/z/oaezas7Ws

@hazohelet : Will you be able to look into this soon?

Thanks for the report and the reproducer.
I cannot take sufficient time for about 36 hours, but I'll be able to investigate it after that.

That is long enough away that I unfortunately have to revert (see 34e49d3e85a6dd03856af0fb4b7f8d8ae1f4f06a). Please note that in the LLVM project reverts are common/frequent (we have a policy of 'revert often'), and should not be taken negatively! Please feel free to re-submit this patch with a fix/the test provided, and we'll re-review promptly!

Thanks for the revert!

It seems that the problem is around the list initializer in template variable definition.
Minimum reproducible example:
template <typename T> constexpr T foo{};

When the TextNodeDumper enabled through -ast-dump visits a constexpr VarDecl with initializer, it evaluates the VarDecl and prints the value if evaluation comes successful.
(https://github.com/llvm/llvm-project/blob/55903151a2a505284ce3fcd955b1d394df0b55ea/clang/lib/AST/TextNodeDumper.cpp#L1825)
The VarDecl::evaluateValue() does not show the notes generated during its failed evaluation. The uninitialized-subobject note is actually generated BEFORE this patch when compiling the reproducers with -ast-dump flag on, but is not shown to the user.
The message should not be generated here and I assume this is an internal bug that we have to fix before resubmitting this patch.

[erichkeane]

In D146358#4357106, @hazohelet wrote:

In D146358#4352792, @erichkeane wrote:

In D146358#4351787, @hazohelet wrote:

In D146358#4350810, @erichkeane wrote:

Our downstream discovered that this causes a regression when compiling utility with ast-dump. I've put up a minimal reproducer: https://godbolt.org/z/oaezas7Ws

@hazohelet : Will you be able to look into this soon?

Thanks for the report and the reproducer.
I cannot take sufficient time for about 36 hours, but I'll be able to investigate it after that.

That is long enough away that I unfortunately have to revert (see 34e49d3e85a6dd03856af0fb4b7f8d8ae1f4f06a). Please note that in the LLVM project reverts are common/frequent (we have a policy of 'revert often'), and should not be taken negatively! Please feel free to re-submit this patch with a fix/the test provided, and we'll re-review promptly!

Thanks for the revert!

It seems that the problem is around the list initializer in template variable definition.
Minimum reproducible example:
template <typename T> constexpr T foo{};

When the TextNodeDumper enabled through -ast-dump visits a constexpr VarDecl with initializer, it evaluates the VarDecl and prints the value if evaluation comes successful.
(https://github.com/llvm/llvm-project/blob/55903151a2a505284ce3fcd955b1d394df0b55ea/clang/lib/AST/TextNodeDumper.cpp#L1825)
The VarDecl::evaluateValue() does not show the notes generated during its failed evaluation. The uninitialized-subobject note is actually generated BEFORE this patch when compiling the reproducers with -ast-dump flag on, but is not shown to the user.
The message should not be generated here and I assume this is an internal bug that we have to fix before resubmitting this patch.

It seems to me that perhaps the assert you added is not appropriate? Instead, could we have the OLD diagnostic 'back' as an alternate form (when this is empty)?

[hazohelet]

In D146358#4357276, @erichkeane wrote:

In D146358#4357106, @hazohelet wrote:

Thanks for the revert!

It seems that the problem is around the list initializer in template variable definition.
Minimum reproducible example:
template <typename T> constexpr T foo{};

When the TextNodeDumper enabled through -ast-dump visits a constexpr VarDecl with initializer, it evaluates the VarDecl and prints the value if evaluation comes successful.
(https://github.com/llvm/llvm-project/blob/55903151a2a505284ce3fcd955b1d394df0b55ea/clang/lib/AST/TextNodeDumper.cpp#L1825)
The VarDecl::evaluateValue() does not show the notes generated during its failed evaluation. The uninitialized-subobject note is actually generated BEFORE this patch when compiling the reproducers with -ast-dump flag on, but is not shown to the user.
The message should not be generated here and I assume this is an internal bug that we have to fix before resubmitting this patch.

It seems to me that perhaps the assert you added is not appropriate? Instead, could we have the OLD diagnostic 'back' as an alternate form (when this is empty)?

If we use the old diagnostic, subobject of type 'const T' is not initialized will be generated internally when clang dumps AST of the reproducer template<typename T> constexpr T foo{};. This is not what we want, right? I want to keep the assert here because it seems to be a nice bug catcher so far.

I did some more investigation and now I am sure that TextNodeDumper should not evaluate the initializer of constexpr-qualified VarDecl if it is an variable template definition(in the code I provided as permalink to GitHub). This approach fixes the assertion failure in the regression.
I opened another differential D151033 for that change, and I think it would be safe to reland this patch once the other is landed.

[hazohelet]

The cause of the regression has been fixed in the other patch.
This is a resubmission with rebase to the upstream.

[aaron.ballman]

In D146358#4364058, @hazohelet wrote:

The cause of the regression has been fixed in the other patch.
This is a resubmission with rebase to the upstream.

LGTM, feel free to land again. I believe the failing precommit CI test is unrelated to the changes here, but please keep an eye on the post-commit bots just in case.

clang/docs/ReleaseNotes.rst

- ``-Wformat`` now recognizes ``%lb`` for the ``printf``/``scanf`` family of
   functions.
   (`#62247: <https://github.com/llvm/llvm-project/issues/62247>`_).
 - Clang now diagnoses shadowing of lambda's template parameter by a capture.
   (`#61105: <https://github.com/llvm/llvm-project/issues/61105>`_).
 - Address a false positive in ``-Wpacked`` when applied to a non-pod type using
   Clang ABI >= 15.
   (`#62353: <https://github.com/llvm/llvm-project/issues/62353>`_,
   fallout from the non-POD packing ABI fix in LLVM 15).
-
+- Clang constexpr evaluator now prints subobject's name instead of its type in notes
+  when a constexpr variable has uninitialized subobjects after its constructor call.
+  (`#58601 <https://github.com/llvm/llvm-project/issues/58601>`_)
 
 Bug Fixes in This Version
 -------------------------
 
 - Fix segfault while running clang-rename on a non existing file.
   (`#36471 <https://github.com/llvm/llvm-project/issues/36471>`_)
 - Fix crash when diagnosing incorrect usage of ``_Nullable`` involving alias
   templates.

clang/include/clang/Basic/DiagnosticASTKinds.td

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">;
+  "subobject %0 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

 /// 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) {
                     diag::note_constexpr_unsupported_temporary_nontrivial_dtor)
             << 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))
+                                 Info, MTE->getExprLoc(), TempType, *V, 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()) {
-    Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized)
-      << true << Type;
-    if (SubobjectLoc.isValid())
-      Info.Note(SubobjectLoc, diag::note_constexpr_subobject_declared_here);
+    assert(SubobjectDecl && "SubobjectDecl shall be non-null");
+    Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized) << SubobjectDecl;
+    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))
+                                 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(),
-        CheckedTemps);
+        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))
+                                 Value.getStructField(I->getFieldIndex()), 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);
+                               /*SubobjectDecl=*/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, /*SubobjectDecl=*/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
     // that in CheckConstantExpression).
     Info.CCEDiag(Info.HeapAllocs.begin()->second.AllocExpr,

clang/lib/AST/Interp/Interp.cpp

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,
-                                           SourceLocation SubObjLoc) {
-  S.FFDiag(SI, diag::note_constexpr_uninitialized) << true << SubObjType;
-  if (SubObjLoc.isValid())
-    S.Note(SubObjLoc, diag::note_constexpr_subobject_declared_here);
+                                           const FieldDecl *SubObjDecl) {
+  assert(SubObjDecl && "Subobject declaration does not exist");
+  S.FFDiag(SI, diag::note_constexpr_uninitialized) << SubObjDecl;
+  S.Note(SubObjDecl->getLocation(),
+         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,
                                   const Pointer &BasePtr,
                                   const ConstantArrayType *CAT) {
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,
-                                       BasePtr.getFieldDesc()->getLocation());
+        DiagnoseUninitializedSubobject(S, S.Current->getSource(OpPC),
+                                       BasePtr.getField());
         Result = false;
       }
     }
   }
 
   return Result;
 }
 
 static bool CheckFieldsInitialized(InterpState &S, CodePtr OpPC,
                                    const Pointer &BasePtr, const Record *R) {
   assert(R);
   bool Result = true;
   // Check all fields of this record are initialized.
   for (const Record::Field &F : R->fields()) {
     Pointer FieldPtr = BasePtr.atField(F.Offset);
     QualType FieldType = F.Decl->getType();
 
     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());
+      DiagnoseUninitializedSubobject(S, S.Current->getSource(OpPC), F.Decl);
       Result = false;
     }
   }
 
   // Check Fields in all bases
   for (const Record::Base &B : R->bases()) {
     Pointer P = BasePtr.atField(B.Offset);
     Result &= CheckFieldsInitialized(S, OpPC, P, B.R);

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];

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/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 'y' 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 'y' 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 '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);