Fix crash on dumping AST containing constant initializer with ParenListExpr

[aaronpuchert]

Summary

The crash was introduced by D83183 (f63e3ea558bb) as far as I can tell.
The problem is that ParenListExprs have a <NULL TYPE> which the
expression evaluation, specifically Expr::EvaluateAsInitializer,
couldn't deal with. One solution would have been to make the evaluation
logic capable of dealing with NULL TYPE, but I rather decided to
harmonize ParenListExprs with InitListExprs, which always have a void
type by default.

Actually I think that the dependent type would not be a bad fit here:
although the type of the contained expression might not be dependent,
the type of the expression itself might be. But this seems like a bigger
change, the assumption that InitListExprs have void type seems to be
baked into quite a few places.

[aaronpuchert]

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

71–73

This is what's currently crashing.

[aaron.ballman]

As far as the changes go, these seem reasonable to me, though I find it a bit odd that these are expressions without a type whereas a ParenExpr has a type of the underlying parenthesized expression. e.g.,

int x(0); // (0) has void type
int y = (0); // (0) has int type

I think my natural assumption is that the init expression would have the type of the thing that's being initialized.

Despite that, I think the changes LG, but I'd like to hear from @rsmith.

[aaronpuchert]

In D98664#2628591, @aaron.ballman wrote:

As far as the changes go, these seem reasonable to me, though I find it a bit odd that these are expressions without a type whereas a ParenExpr has a type of the underlying parenthesized expression. e.g.,

int x(0); // (0) has void type
int y = (0); // (0) has int type

I think my natural assumption is that the init expression would have the type of the thing that's being initialized.

In this case the int type will be assigned when the initialization is carried out in Sema. The void will only remain if we are in a template and the variable being initialized has a dependent type, so we can't carry out the initialization. Also if there are errors. It's similar to int y{0}; in that regard.

If we don't know the type this syntax could be a constructor call, conversion operator call, but also regular value initialization. So we can't use CXXUnresolvedConstructExpr or something like that. That's my understanding.

Despite that, I think the changes LG, but I'd like to hear from @rsmith.

So would I, also about whether to use the dependent type instead.

[aaron.ballman]

In D98664#2628742, @aaronpuchert wrote:

In D98664#2628591, @aaron.ballman wrote:

As far as the changes go, these seem reasonable to me, though I find it a bit odd that these are expressions without a type whereas a ParenExpr has a type of the underlying parenthesized expression. e.g.,

int x(0); // (0) has void type
int y = (0); // (0) has int type

I think my natural assumption is that the init expression would have the type of the thing that's being initialized.

In this case the int type will be assigned when the initialization is carried out in Sema. The void will only remain if we are in a template and the variable being initialized has a dependent type, so we can't carry out the initialization. Also if there are errors. It's similar to int y{0}; in that regard.

If we don't know the type this syntax could be a constructor call, conversion operator call, but also regular value initialization. So we can't use CXXUnresolvedConstructExpr or something like that. That's my understanding.

Ah, thank you for the explanation, that makes sense.

Despite that, I think the changes LG, but I'd like to hear from @rsmith.

So would I, also about whether to use the dependent type instead.

I'm giving my LG, but you should wait for a few days before landing to see if @rsmith has concerns.

clang/include/clang/AST/Expr.h

: public Expr,
       private llvm::TrailingObjects<ParenListExpr, Stmt *> {
   friend class ASTStmtReader;
   friend TrailingObjects;
 
   /// The location of the left and right parentheses.
   SourceLocation LParenLoc, RParenLoc;
 
   /// Build a paren list.
-  ParenListExpr(SourceLocation LParenLoc, ArrayRef<Expr *> Exprs,
-                SourceLocation RParenLoc);
+  ParenListExpr(const ASTContext &C, SourceLocation LParenLoc,
+                ArrayRef<Expr *> Exprs, SourceLocation RParenLoc);
 
   /// Build an empty paren list.
   ParenListExpr(EmptyShell Empty, unsigned NumExprs);
 
 public:
   /// Create a paren list.
   static ParenListExpr *Create(const ASTContext &Ctx, SourceLocation LParenLoc,
                                ArrayRef<Expr *> Exprs,

clang/lib/AST/Expr.cpp

case SourceLocExpr::Column: {
     return APValue(IntVal);
   }
   }
   llvm_unreachable("unhandled case");
 }
 
 InitListExpr::InitListExpr(const ASTContext &C, SourceLocation lbraceloc,
                            ArrayRef<Expr *> initExprs, SourceLocation rbraceloc)
-    : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary),
+    : Expr(InitListExprClass, QualType(C.VoidTy), VK_RValue, OK_Ordinary),
       InitExprs(C, initExprs.size()), LBraceLoc(lbraceloc),
       RBraceLoc(rbraceloc), AltForm(nullptr, true) {
   sawArrayRangeDesignator(false);
   InitExprs.insert(C, InitExprs.end(), initExprs.begin(), initExprs.end());
 
   setDependence(computeDependence(this));
 }
 

 SourceLocation DesignatedInitUpdateExpr::getBeginLoc() const {
   return getBase()->getBeginLoc();
 }
 
 SourceLocation DesignatedInitUpdateExpr::getEndLoc() const {
   return getBase()->getEndLoc();
 }
 
-ParenListExpr::ParenListExpr(SourceLocation LParenLoc, ArrayRef<Expr *> Exprs,
-                             SourceLocation RParenLoc)
-    : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary),
+ParenListExpr::ParenListExpr(const ASTContext &C, SourceLocation LParenLoc,
+                             ArrayRef<Expr *> Exprs, SourceLocation RParenLoc)
+    : Expr(ParenListExprClass, QualType(C.VoidTy), VK_RValue, OK_Ordinary),
       LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
   ParenListExprBits.NumExprs = Exprs.size();
 
   for (unsigned I = 0, N = Exprs.size(); I != N; ++I)
     getTrailingObjects<Stmt *>()[I] = Exprs[I];
   setDependence(computeDependence(this));
 }
 
 ParenListExpr::ParenListExpr(EmptyShell Empty, unsigned NumExprs)
     : Expr(ParenListExprClass, Empty) {
   ParenListExprBits.NumExprs = NumExprs;
 }
 
 ParenListExpr *ParenListExpr::Create(const ASTContext &Ctx,
                                      SourceLocation LParenLoc,
                                      ArrayRef<Expr *> Exprs,
                                      SourceLocation RParenLoc) {
   void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(Exprs.size()),
                            alignof(ParenListExpr));
-  return new (Mem) ParenListExpr(LParenLoc, Exprs, RParenLoc);
+  return new (Mem) ParenListExpr(Ctx, LParenLoc, Exprs, RParenLoc);
 }
 
 ParenListExpr *ParenListExpr::CreateEmpty(const ASTContext &Ctx,
                                           unsigned NumExprs) {
   void *Mem =
       Ctx.Allocate(totalSizeToAlloc<Stmt *>(NumExprs), alignof(ParenListExpr));
   return new (Mem) ParenListExpr(EmptyShell(), NumExprs);
 }

clang/lib/Sema/SemaExpr.cpp

if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
       // Ignore failures; dropping the entire initializer list because
       // of one failure would be terrible for indexing/etc.
       if (result.isInvalid()) continue;
 
       InitArgList[I] = result.get();
     }
   }
 
-  InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList,
-                                               RBraceLoc);
-  E->setType(Context.VoidTy); // FIXME: just a place holder for now.
-  return E;
+  return new (Context) InitListExpr(Context, LBraceLoc, InitArgList, RBraceLoc);
 }
 
 /// Do an explicit extend of the given block pointer if we're in ARC.
 void Sema::maybeExtendBlockObject(ExprResult &E) {
   assert(E.get()->getType()->isBlockPointerType());
   assert(E.get()->isRValue());
 
   // Only do this in an r-value context.

clang/test/AST/ast-dump-expr-json.cpp

 // CHECK-NEXT:                   },
 // CHECK-NEXT:                   "end": {
 // CHECK-NEXT:                    "offset": 1923,
 // CHECK-NEXT:                    "col": 8,
 // CHECK-NEXT:                    "tokLen": 4
 // CHECK-NEXT:                   }
 // CHECK-NEXT:                  },
 // CHECK-NEXT:                  "type": {
-// CHECK-NEXT:                   "qualType": "NULL TYPE"
+// CHECK-NEXT:                   "qualType": "void"
 // CHECK-NEXT:                  },
 // CHECK-NEXT:                  "valueCategory": "rvalue",
 // CHECK-NEXT:                  "inner": [
 // CHECK-NEXT:                   {
 // CHECK-NEXT:                    "id": "0x{{.*}}",
 // CHECK-NEXT:                    "kind": "CXXThisExpr",
 // CHECK-NEXT:                    "range": {
 // CHECK-NEXT:                     "begin": {

 // CHECK-NEXT:                   },
 // CHECK-NEXT:                   "end": {
 // CHECK-NEXT:                    "offset": 1939,
 // CHECK-NEXT:                    "col": 8,
 // CHECK-NEXT:                    "tokLen": 1
 // CHECK-NEXT:                   }
 // CHECK-NEXT:                  },
 // CHECK-NEXT:                  "type": {
-// CHECK-NEXT:                   "qualType": "NULL TYPE"
+// CHECK-NEXT:                   "qualType": "void"
 // CHECK-NEXT:                  },
 // CHECK-NEXT:                  "valueCategory": "rvalue",
 // CHECK-NEXT:                  "inner": [
 // CHECK-NEXT:                   {
 // CHECK-NEXT:                    "id": "0x{{.*}}",
 // CHECK-NEXT:                    "kind": "UnaryOperator",
 // CHECK-NEXT:                    "range": {
 // CHECK-NEXT:                     "begin": {

 // CHECK-NEXT:           },
 // CHECK-NEXT:           "end": {
 // CHECK-NEXT:            "offset": 2007,
 // CHECK-NEXT:            "col": 4,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           }
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "type": {
-// CHECK-NEXT:           "qualType": "NULL TYPE"
+// CHECK-NEXT:           "qualType": "void"
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "valueCategory": "rvalue",
 // CHECK-NEXT:          "inner": [
 // CHECK-NEXT:           {
 // CHECK-NEXT:            "id": "0x{{.*}}",
 // CHECK-NEXT:            "kind": "DeclRefExpr",
 // CHECK-NEXT:            "range": {
 // CHECK-NEXT:             "begin": {

 // CHECK-NEXT:           },
 // CHECK-NEXT:           "end": {
 // CHECK-NEXT:            "offset": 2107,
 // CHECK-NEXT:            "col": 4,
 // CHECK-NEXT:            "tokLen": 1
 // CHECK-NEXT:           }
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "type": {
-// CHECK-NEXT:           "qualType": "NULL TYPE"
+// CHECK-NEXT:           "qualType": "void"
 // CHECK-NEXT:          },
 // CHECK-NEXT:          "valueCategory": "rvalue",
 // CHECK-NEXT:          "inner": [
 // CHECK-NEXT:           {
 // CHECK-NEXT:            "id": "0x{{.*}}",
 // CHECK-NEXT:            "kind": "DeclRefExpr",
 // CHECK-NEXT:            "range": {
 // CHECK-NEXT:             "begin": {

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

void f() {
       // CHECK-NEXT: CopyConstructor
       // CHECK-NEXT: MoveConstructor
       // CHECK-NEXT: CopyAssignment
       // CHECK-NEXT: MoveAssignment
       // CHECK-NEXT: Destructor
       // CHECK-NEXT: CXXMethodDecl
       // CHECK-NEXT: CompoundStmt
       // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:8> col:8 implicit 'V'
-      // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:8> 'NULL TYPE'
+      // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:8> 'void'
       // CHECK-NEXT: UnaryOperator 0x{{[^ ]*}} <col:8> '<dependent type>' prefix '*' cannot overflow
       // CHECK-NEXT: CXXThisExpr 0x{{[^ ]*}} <col:8> 'V *' this
     }
   };
 
   int b, c;
 
   [](){};
void PrimaryExpressions(Ts... a) {
   // CHECK-NEXT: CopyConstructor
   // CHECK-NEXT: MoveConstructor
   // CHECK-NEXT: CopyAssignment
   // CHECK-NEXT: MoveAssignment
   // CHECK-NEXT: Destructor
   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:8, col:10> col:3 operator() 'auto () const -> auto' inline
   // CHECK-NEXT: CompoundStmt
   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:4> col:4 implicit 'Ts...'
-  // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:4> 'NULL TYPE'
+  // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:4> 'void'
   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'Ts' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:9, col:10>
 
   [=]{};
   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:7> '(lambda at {{.*}}:[[@LINE-1]]:3)'
   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
   // CHECK-NEXT: DefinitionData lambda
   // CHECK-NEXT: DefaultConstructor
void PrimaryExpressions(Ts... a) {
   // CHECK-NEXT: MoveConstructor
   // CHECK-NEXT: CopyAssignment
   // CHECK-NEXT: MoveAssignment
   // CHECK-NEXT: Destructor
   // CHECK-NEXT: CXXMethodDecl 0x{{[^ ]*}} <col:16, col:18> col:3 operator() 'auto () const -> auto' inline
   // CHECK-NEXT: CompoundStmt
   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:4> col:4 implicit 'Ts...'
   // CHECK-NEXT: FieldDecl 0x{{[^ ]*}} <col:10> col:10 implicit 'int':'int'
-  // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:4> 'NULL TYPE'
+  // CHECK-NEXT: ParenListExpr 0x{{[^ ]*}} <col:4> 'void'
   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:4> 'Ts' lvalue ParmVar 0x{{[^ ]*}} 'a' 'Ts...'
   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:14> 'int' 12
   // CHECK-NEXT: CompoundStmt 0x{{[^ ]*}} <col:17, col:18>
 
   []() constexpr {};
   // CHECK: LambdaExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:19> '(lambda at {{.*}}:[[@LINE-1]]:3)'
   // CHECK-NEXT: CXXRecordDecl 0x{{[^ ]*}} <col:3> col:3 implicit class definition
   // CHECK-NEXT: DefinitionData lambda

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

 // CHECK-NEXT:    |       | | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT:    |       | | | |-MoveConstructor exists simple trivial needs_implicit
 // CHECK-NEXT:    |       | | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT:    |       | | | |-MoveAssignment
 // CHECK-NEXT:    |       | | | `-Destructor simple irrelevant trivial needs_implicit
 // CHECK-NEXT:    |       | | |-CXXMethodDecl {{.*}} <col:12, col:15> col:7{{( imported)?}} operator() 'auto () const -> auto' inline
 // CHECK-NEXT:    |       | | | `-CompoundStmt {{.*}} <col:14, col:15>
 // CHECK-NEXT:    |       | | `-FieldDecl {{.*}} <col:8> col:8{{( imported)?}} implicit 'V *'
-// CHECK-NEXT:    |       | |-ParenListExpr {{.*}} <col:8> 'NULL TYPE'
+// CHECK-NEXT:    |       | |-ParenListExpr {{.*}} <col:8> 'void'
 // CHECK-NEXT:    |       | | `-CXXThisExpr {{.*}} <col:8> 'V *' this
 // CHECK-NEXT:    |       | `-CompoundStmt {{.*}} <col:14, col:15>
 // CHECK-NEXT:    |       `-LambdaExpr {{.*}} <line:19:7, col:16> '(lambda at {{.*}}ast-dump-lambda.cpp:19:7)'
 // CHECK-NEXT:    |         |-CXXRecordDecl {{.*}} <col:7> col:7{{( imported)?}} implicit{{( <undeserialized declarations>)?}} class definition
 // CHECK-NEXT:    |         | |-DefinitionData lambda standard_layout trivially_copyable can_const_default_init
 // CHECK-NEXT:    |         | | |-DefaultConstructor defaulted_is_constexpr
 // CHECK-NEXT:    |         | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT:    |         | | |-MoveConstructor exists simple trivial needs_implicit
 // CHECK-NEXT:    |         | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT:    |         | | |-MoveAssignment
 // CHECK-NEXT:    |         | | `-Destructor simple irrelevant trivial needs_implicit
 // CHECK-NEXT:    |         | |-CXXMethodDecl {{.*}} <col:13, col:16> col:7{{( imported)?}} operator() 'auto () const -> auto' inline
 // CHECK-NEXT:    |         | | `-CompoundStmt {{.*}} <col:15, col:16>
 // CHECK-NEXT:    |         | `-FieldDecl {{.*}} <col:8> col:8{{( imported)?}} implicit 'V'
-// CHECK-NEXT:    |         |-ParenListExpr {{.*}} <col:8> 'NULL TYPE'
+// CHECK-NEXT:    |         |-ParenListExpr {{.*}} <col:8> 'void'
 // CHECK-NEXT:    |         | `-UnaryOperator {{.*}} <col:8> '<dependent type>' prefix '*' cannot overflow
 // CHECK-NEXT:    |         |   `-CXXThisExpr {{.*}} <col:8> 'V *' this
 // CHECK-NEXT:    |         `-CompoundStmt {{.*}} <col:15, col:16>
 // CHECK-NEXT:    |-DeclStmt {{.*}} <line:22:3, col:11>
 // CHECK-NEXT:    | |-VarDecl {{.*}} <col:3, col:7> col:7{{( imported)?}} referenced b 'int'
 // CHECK-NEXT:    | `-VarDecl {{.*}} <col:3, col:10> col:10{{( imported)?}} referenced c 'int'
 // CHECK-NEXT:    |-LambdaExpr {{.*}} <line:23:3, col:9> '(lambda at {{.*}}ast-dump-lambda.cpp:23:3)'
 // CHECK-NEXT:    | |-CXXRecordDecl {{.*}} <col:3> col:3{{( imported)?}} implicit{{( <undeserialized declarations>)?}} class definition

 // CHECK-NEXT:    | | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT:    | | | |-MoveConstructor exists simple trivial needs_implicit
 // CHECK-NEXT:    | | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT:    | | | |-MoveAssignment
 // CHECK-NEXT:    | | | `-Destructor simple irrelevant trivial needs_implicit
 // CHECK-NEXT:    | | |-CXXMethodDecl {{.*}} <col:8, col:11> col:3{{( imported)?}} operator() 'auto () const -> auto' inline
 // CHECK-NEXT:    | | | `-CompoundStmt {{.*}} <col:10, col:11>
 // CHECK-NEXT:    | | `-FieldDecl {{.*}} <col:4> col:4{{( imported)?}} implicit 'Ts...'
-// CHECK-NEXT:    | |-ParenListExpr {{.*}} <col:4> 'NULL TYPE'
+// CHECK-NEXT:    | |-ParenListExpr {{.*}} <col:4> 'void'
 // CHECK-NEXT:    | | `-DeclRefExpr {{.*}} <col:4> 'Ts' lvalue ParmVar {{.*}} 'a' 'Ts...'
 // CHECK-NEXT:    | `-CompoundStmt {{.*}} <col:10, col:11>
 // CHECK-NEXT:    |-LambdaExpr {{.*}} <line:26:3, col:8> '(lambda at {{.*}}ast-dump-lambda.cpp:26:3)'
 // CHECK-NEXT:    | |-CXXRecordDecl {{.*}} <col:3> col:3{{( imported)?}} implicit{{( <undeserialized declarations>)?}} class definition
 // CHECK-NEXT:    | | |-DefinitionData lambda empty standard_layout trivially_copyable literal can_const_default_init
 // CHECK-NEXT:    | | | |-DefaultConstructor defaulted_is_constexpr
 // CHECK-NEXT:    | | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT:    | | | |-MoveConstructor exists simple trivial needs_implicit

 // CHECK-NEXT:    | | | |-MoveConstructor exists simple trivial needs_implicit
 // CHECK-NEXT:    | | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
 // CHECK-NEXT:    | | | |-MoveAssignment
 // CHECK-NEXT:    | | | `-Destructor simple irrelevant trivial needs_implicit
 // CHECK-NEXT:    | | |-CXXMethodDecl {{.*}} <col:16, col:19> col:3{{( imported)?}} operator() 'auto () const -> auto' inline
 // CHECK-NEXT:    | | | `-CompoundStmt {{.*}} <col:18, col:19>
 // CHECK-NEXT:    | | |-FieldDecl {{.*}} <col:4> col:4{{( imported)?}} implicit 'Ts...'
 // CHECK-NEXT:    | | `-FieldDecl {{.*}} <col:10> col:10{{( imported)?}} implicit 'int':'int'
-// CHECK-NEXT:    | |-ParenListExpr {{.*}} <col:4> 'NULL TYPE'
+// CHECK-NEXT:    | |-ParenListExpr {{.*}} <col:4> 'void'
 // CHECK-NEXT:    | | `-DeclRefExpr {{.*}} <col:4> 'Ts' lvalue ParmVar {{.*}} 'a' 'Ts...'
 // CHECK-NEXT:    | |-IntegerLiteral {{.*}} <col:14> 'int' 12
 // CHECK-NEXT:    | `-CompoundStmt {{.*}} <col:18, col:19>
 // CHECK-NEXT:    |-LambdaExpr {{.*}} <line:32:3, col:19> '(lambda at {{.*}}ast-dump-lambda.cpp:32:3)'
 // CHECK-NEXT:    | |-CXXRecordDecl {{.*}} <col:3> col:3{{( imported)?}} implicit{{( <undeserialized declarations>)?}} class definition
 // CHECK-NEXT:    | | |-DefinitionData lambda empty standard_layout trivially_copyable literal can_const_default_init
 // CHECK-NEXT:    | | | |-DefaultConstructor defaulted_is_constexpr
 // CHECK-NEXT:    | | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param

clang/test/AST/ast-dump-openmp-begin-declare-variant_template_3.cpp

 // CHECK-NEXT: | |-TemplateTypeParmDecl [[ADDR_41:0x[a-z0-9]*]] <line:15:11, col:20> col:20 referenced typename depth 0 index 0 T
 // CHECK-NEXT: | |-FunctionDecl [[ADDR_31]] <line:16:1, line:21:1> line:16:1 referenced also_before[implementation={extension(allow_templates)}] 'int (S<T>)'
 // CHECK-NEXT: | | |-ParmVarDecl [[ADDR_42:0x[a-z0-9]*]] <col:17, col:22> col:22 s 'S<T>'
 // CHECK-NEXT: | | `-CompoundStmt [[ADDR_43:0x[a-z0-9]*]] <col:25, line:21:1>
 // CHECK-NEXT: | |   |-DeclStmt [[ADDR_44:0x[a-z0-9]*]] <line:18:3, col:11>
 // CHECK-NEXT: | |   | `-VarDecl [[ADDR_45:0x[a-z0-9]*]] <col:3, col:10> col:10 referenced t 'double'
 // CHECK-NEXT: | |   |-DeclStmt [[ADDR_46:0x[a-z0-9]*]] <line:19:3, col:16>
 // CHECK-NEXT: | |   | `-VarDecl [[ADDR_47:0x[a-z0-9]*]] <col:3, col:15> col:8 q 'S<T>' callinit
-// CHECK-NEXT: | |   |   `-ParenListExpr [[ADDR_48:0x[a-z0-9]*]] <col:9, col:15> 'NULL TYPE'
+// CHECK-NEXT: | |   |   `-ParenListExpr [[ADDR_48:0x[a-z0-9]*]] <col:9, col:15> 'void'
 // CHECK-NEXT: | |   |     |-IntegerLiteral [[ADDR_49:0x[a-z0-9]*]] <col:10> 'int' 1
 // CHECK-NEXT: | |   |     `-UnaryOperator [[ADDR_50:0x[a-z0-9]*]] <col:13, col:14> 'double *' prefix '&' cannot overflow
 // CHECK-NEXT: | |   |       `-DeclRefExpr [[ADDR_51:0x[a-z0-9]*]] <col:14> 'double' {{.*}}Var [[ADDR_45]] 't' 'double'
 // CHECK-NEXT: | |   `-ReturnStmt [[ADDR_52:0x[a-z0-9]*]] <line:20:3, col:10>
 // CHECK-NEXT: | |     `-IntegerLiteral [[ADDR_53:0x[a-z0-9]*]] <col:10> 'int' 1
 // CHECK-NEXT: | |-FunctionDecl [[ADDR_54:0x[a-z0-9]*]] <line:16:1, line:21:1> line:16:1 also_before[implementation={extension(allow_templates)}] 'int (S<int>)'
 // CHECK-NEXT: | | |-TemplateArgument type 'int'
 // CHECK-NEXT: | | | `-BuiltinType [[ADDR_9]] 'int'

 // CHECK-NEXT: | |-TemplateTypeParmDecl [[ADDR_59]] <line:22:11, col:20> col:20 referenced typename depth 0 index 0 T
 // CHECK-NEXT: | |-FunctionDecl [[ADDR_64]] <line:23:1, line:27:1> line:23:1 referenced special[implementation={extension(allow_templates)}] 'int (S<T>)'
 // CHECK-NEXT: | | |-ParmVarDecl [[ADDR_61]] <col:13, col:18> col:18 s 'S<T>'
 // CHECK-NEXT: | | `-CompoundStmt [[ADDR_71:0x[a-z0-9]*]] <col:21, line:27:1>
 // CHECK-NEXT: | |   |-DeclStmt [[ADDR_72:0x[a-z0-9]*]] <line:24:3, col:6>
 // CHECK-NEXT: | |   | `-VarDecl [[ADDR_73:0x[a-z0-9]*]] <col:3, col:5> col:5 referenced t 'T'
 // CHECK-NEXT: | |   |-DeclStmt [[ADDR_74:0x[a-z0-9]*]] <line:25:3, col:16>
 // CHECK-NEXT: | |   | `-VarDecl [[ADDR_75:0x[a-z0-9]*]] <col:3, col:15> col:8 q 'S<T>' callinit
-// CHECK-NEXT: | |   |   `-ParenListExpr [[ADDR_76:0x[a-z0-9]*]] <col:9, col:15> 'NULL TYPE'
+// CHECK-NEXT: | |   |   `-ParenListExpr [[ADDR_76:0x[a-z0-9]*]] <col:9, col:15> 'void'
 // CHECK-NEXT: | |   |     |-IntegerLiteral [[ADDR_77:0x[a-z0-9]*]] <col:10> 'int' 0
 // CHECK-NEXT: | |   |     `-UnaryOperator [[ADDR_78:0x[a-z0-9]*]] <col:13, col:14> '<dependent type>' prefix '&' cannot overflow
 // CHECK-NEXT: | |   |       `-DeclRefExpr [[ADDR_79:0x[a-z0-9]*]] <col:14> 'T' {{.*}}Var [[ADDR_73]] 't' 'T'
 // CHECK-NEXT: | |   `-ReturnStmt [[ADDR_80:0x[a-z0-9]*]] <line:26:3, col:10>
 // CHECK-NEXT: | |     `-IntegerLiteral [[ADDR_81:0x[a-z0-9]*]] <col:10> 'int' 0
 // CHECK-NEXT: | `-FunctionDecl [[ADDR_69]] <line:23:1, line:27:1> line:23:1 special[implementation={extension(allow_templates)}] 'int (S<int>)'
 // CHECK-NEXT: |   |-TemplateArgument type 'int'
 // CHECK-NEXT: |   | `-BuiltinType [[ADDR_9]] 'int'

 // CHECK-NEXT: | |-TemplateTypeParmDecl [[ADDR_93]] <line:28:11, col:20> col:20 referenced typename depth 0 index 0 T
 // CHECK-NEXT: | `-FunctionDecl [[ADDR_98]] <line:29:1, line:34:1> line:29:1 also_after[implementation={extension(allow_templates)}] 'int (S<T>)'
 // CHECK-NEXT: |   |-ParmVarDecl [[ADDR_95]] <col:16, col:21> col:21 s 'S<T>'
 // CHECK-NEXT: |   `-CompoundStmt [[ADDR_100:0x[a-z0-9]*]] <col:24, line:34:1>
 // CHECK-NEXT: |     |-DeclStmt [[ADDR_101:0x[a-z0-9]*]] <line:31:3, col:11>
 // CHECK-NEXT: |     | `-VarDecl [[ADDR_102:0x[a-z0-9]*]] <col:3, col:10> col:10 referenced t 'double'
 // CHECK-NEXT: |     |-DeclStmt [[ADDR_103:0x[a-z0-9]*]] <line:32:3, col:18>
 // CHECK-NEXT: |     | `-VarDecl [[ADDR_104:0x[a-z0-9]*]] <col:3, col:17> col:8 q 'S<T>' callinit
-// CHECK-NEXT: |     |   `-ParenListExpr [[ADDR_105:0x[a-z0-9]*]] <col:9, col:17> 'NULL TYPE'
+// CHECK-NEXT: |     |   `-ParenListExpr [[ADDR_105:0x[a-z0-9]*]] <col:9, col:17> 'void'
 // CHECK-NEXT: |     |     |-FloatingLiteral [[ADDR_106:0x[a-z0-9]*]] <col:10> 'double' 2.000000e+00
 // CHECK-NEXT: |     |     `-UnaryOperator [[ADDR_107:0x[a-z0-9]*]] <col:15, col:16> 'double *' prefix '&' cannot overflow
 // CHECK-NEXT: |     |       `-DeclRefExpr [[ADDR_108:0x[a-z0-9]*]] <col:16> 'double' {{.*}}Var [[ADDR_102]] 't' 'double'
 // CHECK-NEXT: |     `-ReturnStmt [[ADDR_109:0x[a-z0-9]*]] <line:33:3, col:10>
 // CHECK-NEXT: |       `-IntegerLiteral [[ADDR_110:0x[a-z0-9]*]] <col:10> 'int' 2
 // CHECK-NEXT: |-FunctionTemplateDecl [[ADDR_111:0x[a-z0-9]*]] <line:37:1, line:40:1> line:38:5 also_after
 // CHECK-NEXT: | |-TemplateTypeParmDecl [[ADDR_112:0x[a-z0-9]*]] <line:37:11, col:20> col:20 referenced typename depth 0 index 0 T
 // CHECK-NEXT: | |-FunctionDecl [[ADDR_113:0x[a-z0-9]*]] <line:38:1, line:40:1> line:38:5 also_after 'int (T)'

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

void InvalidInitalizer(int x) {
   // CHECK-NEXT:  `-DeclRefExpr {{.*}} 'x'
   Bar a2(x);
   // CHECK:     `-VarDecl {{.*}} a3 'Bar'
   // CHECK-NEXT: `-RecoveryExpr {{.*}} contains-errors
   // CHECK-NEXT:  `-InitListExpr
   // CHECK-NEDT:   `-DeclRefExpr {{.*}} 'x'
   Bar a3{x};
   // CHECK:     `-VarDecl {{.*}} a4 'Bar'
-  // CHECK-NEXT: `-ParenListExpr {{.*}} 'NULL TYPE' contains-errors
+  // CHECK-NEXT: `-ParenListExpr {{.*}} contains-errors
   // CHECK-NEXT:  `-RecoveryExpr {{.*}} contains-errors
   // CHECK-NEXT:   `-UnresolvedLookupExpr {{.*}} 'invalid'
   Bar a4(invalid());
   // CHECK:     `-VarDecl {{.*}} a5 'Bar'
   // CHECK-NEXT: `-InitListExpr {{.*}} contains-errors
   // CHECK-NEXT:  `-RecoveryExpr {{.*}} contains-errors
   // CHECK-NEXT:   `-UnresolvedLookupExpr {{.*}} 'invalid'
   Bar a5{invalid()};

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

 // DUMP: UnresolvedLookupExpr {{.*}} <col:3> '<overloaded function type>' lvalue (ADL) = 'func'
 }
 
 namespace test3 {
   template<typename T> struct A {};
   template<typename T> A(T) -> A<int>;
   // CHECK1: template <typename T> A(T) -> A<int>;
 }
+
+template <typename T> constexpr T var(0);
+// DUMP: VarDecl {{.*}} <col:23, col:40> col:35 var 'const T' constexpr callinit
+// DUMP-NEXT: ParenListExpr {{.*}} <col:38, col:40> 'void'