[clang][AST] TextNodeDumper should not evaluate the initializer of constexpr variable declaration when it has a dependent type

[hazohelet]

Summary

TextNodeDumper enabed through -ast-dump flag should not evlauate the initializer when it visits a constexpr VarDecl node if it has a dependent type.

I found a crashing case fixed by this change and added it as a test case.
template <typename T> constexpr T call_init(0);
Link: https://godbolt.org/z/3bG9Pjj5E

This is a fix for the regression caused by D146358

[tbaeder]

Can you briefly explain why the FieldDecl we see is null in that case?

[hazohelet]

In D151033#4359121, @tbaeder wrote:

Can you briefly explain why the FieldDecl we see is null in that case?

Consider template<typename T> constexpr T foo{};

evaluateValue here leads to a call of EvaluateAsInitializer. It calls CheckConstantExpression, which leads to the call of CheckEvaluationResult with null FieldDecl.
The APValue-typed Value argument passed to CheckConstantExpression should hasValue bacause otherwise it would cause assertion failure we saw before.
This Value object is calculated at Evaluate function called from EvaluateAsInitializer.
The evaluated Expr object is InitListExpr that has type void, so the branch for void-typed expression(https://github.com/llvm/llvm-project/blob/8b1727f8d9104df5ced4bdfdc065dea85ff84baf/clang/lib/AST/ExprConstant.cpp#L15041-L15046) is fired.
In this branch, the Result argument is left untouched, which leads to CheckEvaluationResult receiving Value object whose hasValue evaluates to false.

BTW, I noticed that when the type of the declaration is NOT a dependent type (e.g. template <typename T> constexpr int foo{42} ), we need to evaluate the initializer and dump the value. I'll update the patch and retitle it.

[hazohelet]

• Evaluate the initializer if the type of the declaration is not a dependent type
• Add a relevant test
• Update release note for this change

clang/docs/ReleaseNotes.rst

 - Fix a crash when an enum constant has a dependent-type recovery expression for
   C.
   (`#62446 <https://github.com/llvm/llvm-project/issues/62446>`_).
 - Propagate the value-dependent bit for VAArgExpr. Fixes a crash where a
   __builtin_va_arg call has invalid arguments.
   (`#62711 <https://github.com/llvm/llvm-project/issues/62711>`_).
 - Fix crash on attempt to initialize union with flexible array member.
   (`#61746 <https://github.com/llvm/llvm-project/issues/61746>`_).
+- Clang `TextNodeDumper` enabled through `-ast-dump` flag no longer evaluates the
+  initializer of constexpr `VarDecl` if the declaration has a dependent type.
 
 Bug Fixes to Compiler Builtins
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Bug Fixes to Attribute Support
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Fixed a bug where attribute annotations on type specifiers (enums, classes,
   structs, unions, and scoped enums) were not properly ignored, resulting in

clang/lib/AST/TextNodeDumper.cpp

void TextNodeDumper::VisitVarDecl(const VarDecl *D) {
   if (D->needsDestruction(D->getASTContext()))
     OS << " destroyed";
   if (D->isParameterPack())
     OS << " pack";
 
   if (D->hasInit()) {
     const Expr *E = D->getInit();
     // Only dump the value of constexpr VarDecls for now.
-    if (E && !E->isValueDependent() && D->isConstexpr()) {
+    if (E && !E->isValueDependent() && D->isConstexpr() &&
+        !D->getType()->isDependentType()) {
       const APValue *Value = D->evaluateValue();
       if (Value)
         AddChild("value", [=] { Visit(*Value, E->getType()); });
     }
   }
 }
 
 void TextNodeDumper::VisitBindingDecl(const BindingDecl *D) {

clang/test/AST/ast-dump-decl.cpp

 // CHECK: VarDecl {{.*}} Test 'int' extern
 // CHECK-NOT: FullComment
 // CHECK: VarDecl {{.*}} Test 'int' extern
 // CHECK: `-FullComment
 // CHECK:   `-ParagraphComment
 // CHECK:       `-TextComment
 // CHECK: VarDecl {{.*}} Test 'int' extern
 // CHECK-NOT: FullComment
+
+namespace TestConstexprVariableTemplateWithInitializer {
+  template<typename T> constexpr T foo{};
+  // CHECK:      VarTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-1]]:3, col:40> col:36 foo
+  // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 referenced typename depth 0 index 0 T
+  // CHECK-NEXT: `-VarDecl 0x{{.+}} <col:24, col:40> col:36 foo 'const T' constexpr listinit
+  // CHECK-NEXT:  `-InitListExpr 0x{{.+}} <col:39, col:40> 'void'
+
+  template<typename T> constexpr int val{42};
+  // CHECK:      VarTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-1]]:3, col:44> col:38 val
+  // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:12, col:21> col:21 typename depth 0 index 0 T
+  // CHECK-NEXT: `-VarDecl 0x{{.+}} <col:24, col:44> col:38 val 'const int' constexpr listinit
+  // CHECK-NEXT:  |-value: Int 42
+  // CHECK-NEXT:  `-InitListExpr 0x{{.+}} <col:41, col:44> 'int'
+
+  template <typename _Tp>
+  struct in_place_type_t {
+    explicit in_place_type_t() = default;
+  };
+
+  template <typename _Tp>
+  inline constexpr in_place_type_t<_Tp> in_place_type{};
+  // CHECK:     -VarTemplateDecl 0x{{.+}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:55> col:41 in_place_type
+  // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <line:[[@LINE-3]]:13, col:22> col:22 referenced typename depth 0 index 0 _Tp
+  // CHECK-NEXT: `-VarDecl 0x{{.+}} <line:[[@LINE-3]]:3, col:55> col:41 in_place_type 'const in_place_type_t<_Tp>':'const in_place_type_t<_Tp>' inline constexpr listinit
+  // CHECK-NEXT:  `-InitListExpr 0x{{.+}} <col:54, col:55> 'void'
+
+  template <typename T> constexpr T call_init(0);
+  // CHECK:     -VarTemplateDecl 0x{{.+}} <line:[[@LINE-1]]:3, col:48> col:37 call_init
+  // CHECK-NEXT: |-TemplateTypeParmDecl 0x{{.+}} <col:13, col:22> col:22 referenced typename depth 0 index 0 T
+  // CHECK-NEXT: `-VarDecl 0x{{.+}} <col:25, col:48> col:37 call_init 'const T' constexpr callinit
+  // CHECK-NEXT:  `-ParenListExpr 0x{{.+}} <col:46, col:48> 'NULL TYPE'
+  // CHECK-NEXT:   `-IntegerLiteral 0x{{.+}} <col:47> 'int' 0
+
+}