Clang Project

clang_source_code/lib/AST/TextNodeDumper.cpp
1//===--- TextNodeDumper.cpp - Printing of AST nodes -----------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements AST dumping of components of individual AST nodes.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/TextNodeDumper.h"
14#include "clang/AST/DeclFriend.h"
15#include "clang/AST/DeclOpenMP.h"
16#include "clang/AST/DeclTemplate.h"
17#include "clang/AST/LocInfoType.h"
18
19using namespace clang;
20
21static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {}
22
23template <typename T>
24static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) {
25  const T *First = D->getFirstDecl();
26  if (First != D)
27    OS << " first " << First;
28}
29
30template <typename T>
31static void dumpPreviousDeclImpl(raw_ostream &OS, const Redeclarable<T> *D) {
32  const T *Prev = D->getPreviousDecl();
33  if (Prev)
34    OS << " prev " << Prev;
35}
36
37/// Dump the previous declaration in the redeclaration chain for a declaration,
38/// if any.
39static void dumpPreviousDecl(raw_ostream &OS, const Decl *D) {
40  switch (D->getKind()) {
41#define DECL(DERIVED, BASE)                                                    \
42  case Decl::DERIVED:                                                          \
43    return dumpPreviousDeclImpl(OS, cast<DERIVED##Decl>(D));
44#define ABSTRACT_DECL(DECL)
45#include "clang/AST/DeclNodes.inc"
46  }
47  llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
48}
49
50TextNodeDumper::TextNodeDumper(raw_ostream &OS, bool ShowColors,
51                               const SourceManager *SM,
52                               const PrintingPolicy &PrintPolicy,
53                               const comments::CommandTraits *Traits)
54    : TextTreeStructure(OS, ShowColors), OS(OS), ShowColors(ShowColors), SM(SM),
55      PrintPolicy(PrintPolicy), Traits(Traits) {}
56
57void TextNodeDumper::Visit(const comments::Comment *C,
58                           const comments::FullComment *FC) {
59  if (!C) {
60    ColorScope Color(OS, ShowColors, NullColor);
61    OS << "<<<NULL>>>";
62    return;
63  }
64
65  {
66    ColorScope Color(OS, ShowColors, CommentColor);
67    OS << C->getCommentKindName();
68  }
69  dumpPointer(C);
70  dumpSourceRange(C->getSourceRange());
71
72  ConstCommentVisitor<TextNodeDumper, void,
73                      const comments::FullComment *>::visit(C, FC);
74}
75
76void TextNodeDumper::Visit(const Attr *A) {
77  {
78    ColorScope Color(OS, ShowColors, AttrColor);
79
80    switch (A->getKind()) {
81#define ATTR(X)                                                                \
82  case attr::X:                                                                \
83    OS << #X;                                                                  \
84    break;
85#include "clang/Basic/AttrList.inc"
86    }
87    OS << "Attr";
88  }
89  dumpPointer(A);
90  dumpSourceRange(A->getRange());
91  if (A->isInherited())
92    OS << " Inherited";
93  if (A->isImplicit())
94    OS << " Implicit";
95
96  ConstAttrVisitor<TextNodeDumper>::Visit(A);
97}
98
99void TextNodeDumper::Visit(const TemplateArgument &TA, SourceRange R,
100                           const Decl *From, StringRef Label) {
101  OS << "TemplateArgument";
102  if (R.isValid())
103    dumpSourceRange(R);
104
105  if (From)
106    dumpDeclRef(From, Label);
107
108  ConstTemplateArgumentVisitor<TextNodeDumper>::Visit(TA);
109}
110
111void TextNodeDumper::Visit(const Stmt *Node) {
112  if (!Node) {
113    ColorScope Color(OS, ShowColors, NullColor);
114    OS << "<<<NULL>>>";
115    return;
116  }
117  {
118    ColorScope Color(OS, ShowColors, StmtColor);
119    OS << Node->getStmtClassName();
120  }
121  dumpPointer(Node);
122  dumpSourceRange(Node->getSourceRange());
123
124  if (Node->isOMPStructuredBlock())
125    OS << " openmp_structured_block";
126
127  if (const auto *E = dyn_cast<Expr>(Node)) {
128    dumpType(E->getType());
129
130    {
131      ColorScope Color(OS, ShowColors, ValueKindColor);
132      switch (E->getValueKind()) {
133      case VK_RValue:
134        break;
135      case VK_LValue:
136        OS << " lvalue";
137        break;
138      case VK_XValue:
139        OS << " xvalue";
140        break;
141      }
142    }
143
144    {
145      ColorScope Color(OS, ShowColors, ObjectKindColor);
146      switch (E->getObjectKind()) {
147      case OK_Ordinary:
148        break;
149      case OK_BitField:
150        OS << " bitfield";
151        break;
152      case OK_ObjCProperty:
153        OS << " objcproperty";
154        break;
155      case OK_ObjCSubscript:
156        OS << " objcsubscript";
157        break;
158      case OK_VectorComponent:
159        OS << " vectorcomponent";
160        break;
161      }
162    }
163  }
164
165  ConstStmtVisitor<TextNodeDumper>::Visit(Node);
166}
167
168void TextNodeDumper::Visit(const Type *T) {
169  if (!T) {
170    ColorScope Color(OS, ShowColors, NullColor);
171    OS << "<<<NULL>>>";
172    return;
173  }
174  if (isa<LocInfoType>(T)) {
175    {
176      ColorScope Color(OS, ShowColors, TypeColor);
177      OS << "LocInfo Type";
178    }
179    dumpPointer(T);
180    return;
181  }
182
183  {
184    ColorScope Color(OS, ShowColors, TypeColor);
185    OS << T->getTypeClassName() << "Type";
186  }
187  dumpPointer(T);
188  OS << " ";
189  dumpBareType(QualType(T, 0), false);
190
191  QualType SingleStepDesugar =
192      T->getLocallyUnqualifiedSingleStepDesugaredType();
193  if (SingleStepDesugar != QualType(T, 0))
194    OS << " sugar";
195
196  if (T->isDependentType())
197    OS << " dependent";
198  else if (T->isInstantiationDependentType())
199    OS << " instantiation_dependent";
200
201  if (T->isVariablyModifiedType())
202    OS << " variably_modified";
203  if (T->containsUnexpandedParameterPack())
204    OS << " contains_unexpanded_pack";
205  if (T->isFromAST())
206    OS << " imported";
207
208  TypeVisitor<TextNodeDumper>::Visit(T);
209}
210
211void TextNodeDumper::Visit(QualType T) {
212  OS << "QualType";
213  dumpPointer(T.getAsOpaquePtr());
214  OS << " ";
215  dumpBareType(T, false);
216  OS << " " << T.split().Quals.getAsString();
217}
218
219void TextNodeDumper::Visit(const Decl *D) {
220  if (!D) {
221    ColorScope Color(OS, ShowColors, NullColor);
222    OS << "<<<NULL>>>";
223    return;
224  }
225
226  {
227    ColorScope Color(OS, ShowColors, DeclKindNameColor);
228    OS << D->getDeclKindName() << "Decl";
229  }
230  dumpPointer(D);
231  if (D->getLexicalDeclContext() != D->getDeclContext())
232    OS << " parent " << cast<Decl>(D->getDeclContext());
233  dumpPreviousDecl(OS, D);
234  dumpSourceRange(D->getSourceRange());
235  OS << ' ';
236  dumpLocation(D->getLocation());
237  if (D->isFromASTFile())
238    OS << " imported";
239  if (Module *M = D->getOwningModule())
240    OS << " in " << M->getFullModuleName();
241  if (auto *ND = dyn_cast<NamedDecl>(D))
242    for (Module *M : D->getASTContext().getModulesWithMergedDefinition(
243             const_cast<NamedDecl *>(ND)))
244      AddChild([=] { OS << "also in " << M->getFullModuleName(); });
245  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
246    if (ND->isHidden())
247      OS << " hidden";
248  if (D->isImplicit())
249    OS << " implicit";
250
251  if (D->isUsed())
252    OS << " used";
253  else if (D->isThisDeclarationReferenced())
254    OS << " referenced";
255
256  if (D->isInvalidDecl())
257    OS << " invalid";
258  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
259    if (FD->isConstexpr())
260      OS << " constexpr";
261
262  if (!isa<FunctionDecl>(*D)) {
263    const auto *MD = dyn_cast<ObjCMethodDecl>(D);
264    if (!MD || !MD->isThisDeclarationADefinition()) {
265      const auto *DC = dyn_cast<DeclContext>(D);
266      if (DC && DC->hasExternalLexicalStorage()) {
267        ColorScope Color(OS, ShowColors, UndeserializedColor);
268        OS << " <undeserialized declarations>";
269      }
270    }
271  }
272
273  ConstDeclVisitor<TextNodeDumper>::Visit(D);
274}
275
276void TextNodeDumper::Visit(const CXXCtorInitializer *Init) {
277  OS << "CXXCtorInitializer";
278  if (Init->isAnyMemberInitializer()) {
279    OS << ' ';
280    dumpBareDeclRef(Init->getAnyMember());
281  } else if (Init->isBaseInitializer()) {
282    dumpType(QualType(Init->getBaseClass(), 0));
283  } else if (Init->isDelegatingInitializer()) {
284    dumpType(Init->getTypeSourceInfo()->getType());
285  } else {
286    llvm_unreachable("Unknown initializer type");
287  }
288}
289
290void TextNodeDumper::Visit(const BlockDecl::Capture &C) {
291  OS << "capture";
292  if (C.isByRef())
293    OS << " byref";
294  if (C.isNested())
295    OS << " nested";
296  if (C.getVariable()) {
297    OS << ' ';
298    dumpBareDeclRef(C.getVariable());
299  }
300}
301
302void TextNodeDumper::Visit(const OMPClause *C) {
303  if (!C) {
304    ColorScope Color(OS, ShowColors, NullColor);
305    OS << "<<<NULL>>> OMPClause";
306    return;
307  }
308  {
309    ColorScope Color(OS, ShowColors, AttrColor);
310    StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
311    OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
312       << ClauseName.drop_front() << "Clause";
313  }
314  dumpPointer(C);
315  dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
316  if (C->isImplicit())
317    OS << " <implicit>";
318}
319
320void TextNodeDumper::Visit(const GenericSelectionExpr::ConstAssociation &A) {
321  const TypeSourceInfo *TSI = A.getTypeSourceInfo();
322  if (TSI) {
323    OS << "case ";
324    dumpType(TSI->getType());
325  } else {
326    OS << "default";
327  }
328
329  if (A.isSelected())
330    OS << " selected";
331}
332
333void TextNodeDumper::dumpPointer(const void *Ptr) {
334  ColorScope Color(OS, ShowColors, AddressColor);
335  OS << ' ' << Ptr;
336}
337
338void TextNodeDumper::dumpLocation(SourceLocation Loc) {
339  if (!SM)
340    return;
341
342  ColorScope Color(OS, ShowColors, LocationColor);
343  SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
344
345  // The general format we print out is filename:line:col, but we drop pieces
346  // that haven't changed since the last loc printed.
347  PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
348
349  if (PLoc.isInvalid()) {
350    OS << "<invalid sloc>";
351    return;
352  }
353
354  if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
355    OS << PLoc.getFilename() << ':' << PLoc.getLine() << ':'
356       << PLoc.getColumn();
357    LastLocFilename = PLoc.getFilename();
358    LastLocLine = PLoc.getLine();
359  } else if (PLoc.getLine() != LastLocLine) {
360    OS << "line" << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
361    LastLocLine = PLoc.getLine();
362  } else {
363    OS << "col" << ':' << PLoc.getColumn();
364  }
365}
366
367void TextNodeDumper::dumpSourceRange(SourceRange R) {
368  // Can't translate locations if a SourceManager isn't available.
369  if (!SM)
370    return;
371
372  OS << " <";
373  dumpLocation(R.getBegin());
374  if (R.getBegin() != R.getEnd()) {
375    OS << ", ";
376    dumpLocation(R.getEnd());
377  }
378  OS << ">";
379
380  // <t2.c:123:421[blah], t2.c:412:321>
381}
382
383void TextNodeDumper::dumpBareType(QualType T, bool Desugar) {
384  ColorScope Color(OS, ShowColors, TypeColor);
385
386  SplitQualType T_split = T.split();
387  OS << "'" << QualType::getAsString(T_split, PrintPolicy) << "'";
388
389  if (Desugar && !T.isNull()) {
390    // If the type is sugared, also dump a (shallow) desugared type.
391    SplitQualType D_split = T.getSplitDesugaredType();
392    if (T_split != D_split)
393      OS << ":'" << QualType::getAsString(D_split, PrintPolicy) << "'";
394  }
395}
396
397void TextNodeDumper::dumpType(QualType T) {
398  OS << ' ';
399  dumpBareType(T);
400}
401
402void TextNodeDumper::dumpBareDeclRef(const Decl *D) {
403  if (!D) {
404    ColorScope Color(OS, ShowColors, NullColor);
405    OS << "<<<NULL>>>";
406    return;
407  }
408
409  {
410    ColorScope Color(OS, ShowColors, DeclKindNameColor);
411    OS << D->getDeclKindName();
412  }
413  dumpPointer(D);
414
415  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
416    ColorScope Color(OS, ShowColors, DeclNameColor);
417    OS << " '" << ND->getDeclName() << '\'';
418  }
419
420  if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
421    dumpType(VD->getType());
422}
423
424void TextNodeDumper::dumpName(const NamedDecl *ND) {
425  if (ND->getDeclName()) {
426    ColorScope Color(OS, ShowColors, DeclNameColor);
427    OS << ' ' << ND->getNameAsString();
428  }
429}
430
431void TextNodeDumper::dumpAccessSpecifier(AccessSpecifier AS) {
432  switch (AS) {
433  case AS_none:
434    break;
435  case AS_public:
436    OS << "public";
437    break;
438  case AS_protected:
439    OS << "protected";
440    break;
441  case AS_private:
442    OS << "private";
443    break;
444  }
445}
446
447void TextNodeDumper::dumpCXXTemporary(const CXXTemporary *Temporary) {
448  OS << "(CXXTemporary";
449  dumpPointer(Temporary);
450  OS << ")";
451}
452
453void TextNodeDumper::dumpDeclRef(const Decl *D, StringRef Label) {
454  if (!D)
455    return;
456
457  AddChild([=] {
458    if (!Label.empty())
459      OS << Label << ' ';
460    dumpBareDeclRef(D);
461  });
462}
463
464const char *TextNodeDumper::getCommandName(unsigned CommandID) {
465  if (Traits)
466    return Traits->getCommandInfo(CommandID)->Name;
467  const comments::CommandInfo *Info =
468      comments::CommandTraits::getBuiltinCommandInfo(CommandID);
469  if (Info)
470    return Info->Name;
471  return "<not a builtin command>";
472}
473
474void TextNodeDumper::visitTextComment(const comments::TextComment *C,
475                                      const comments::FullComment *) {
476  OS << " Text=\"" << C->getText() << "\"";
477}
478
479void TextNodeDumper::visitInlineCommandComment(
480    const comments::InlineCommandComment *C, const comments::FullComment *) {
481  OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
482  switch (C->getRenderKind()) {
483  case comments::InlineCommandComment::RenderNormal:
484    OS << " RenderNormal";
485    break;
486  case comments::InlineCommandComment::RenderBold:
487    OS << " RenderBold";
488    break;
489  case comments::InlineCommandComment::RenderMonospaced:
490    OS << " RenderMonospaced";
491    break;
492  case comments::InlineCommandComment::RenderEmphasized:
493    OS << " RenderEmphasized";
494    break;
495  }
496
497  for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
498    OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
499}
500
501void TextNodeDumper::visitHTMLStartTagComment(
502    const comments::HTMLStartTagComment *C, const comments::FullComment *) {
503  OS << " Name=\"" << C->getTagName() << "\"";
504  if (C->getNumAttrs() != 0) {
505    OS << " Attrs: ";
506    for (unsigned i = 0, e = C->getNumAttrs(); i != e; ++i) {
507      const comments::HTMLStartTagComment::Attribute &Attr = C->getAttr(i);
508      OS << " \"" << Attr.Name << "=\"" << Attr.Value << "\"";
509    }
510  }
511  if (C->isSelfClosing())
512    OS << " SelfClosing";
513}
514
515void TextNodeDumper::visitHTMLEndTagComment(
516    const comments::HTMLEndTagComment *C, const comments::FullComment *) {
517  OS << " Name=\"" << C->getTagName() << "\"";
518}
519
520void TextNodeDumper::visitBlockCommandComment(
521    const comments::BlockCommandComment *C, const comments::FullComment *) {
522  OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
523  for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
524    OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
525}
526
527void TextNodeDumper::visitParamCommandComment(
528    const comments::ParamCommandComment *C, const comments::FullComment *FC) {
529  OS << " "
530     << comments::ParamCommandComment::getDirectionAsString(C->getDirection());
531
532  if (C->isDirectionExplicit())
533    OS << " explicitly";
534  else
535    OS << " implicitly";
536
537  if (C->hasParamName()) {
538    if (C->isParamIndexValid())
539      OS << " Param=\"" << C->getParamName(FC) << "\"";
540    else
541      OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
542  }
543
544  if (C->isParamIndexValid() && !C->isVarArgParam())
545    OS << " ParamIndex=" << C->getParamIndex();
546}
547
548void TextNodeDumper::visitTParamCommandComment(
549    const comments::TParamCommandComment *C, const comments::FullComment *FC) {
550  if (C->hasParamName()) {
551    if (C->isPositionValid())
552      OS << " Param=\"" << C->getParamName(FC) << "\"";
553    else
554      OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
555  }
556
557  if (C->isPositionValid()) {
558    OS << " Position=<";
559    for (unsigned i = 0, e = C->getDepth(); i != e; ++i) {
560      OS << C->getIndex(i);
561      if (i != e - 1)
562        OS << ", ";
563    }
564    OS << ">";
565  }
566}
567
568void TextNodeDumper::visitVerbatimBlockComment(
569    const comments::VerbatimBlockComment *C, const comments::FullComment *) {
570  OS << " Name=\"" << getCommandName(C->getCommandID())
571     << "\""
572        " CloseName=\""
573     << C->getCloseName() << "\"";
574}
575
576void TextNodeDumper::visitVerbatimBlockLineComment(
577    const comments::VerbatimBlockLineComment *C,
578    const comments::FullComment *) {
579  OS << " Text=\"" << C->getText() << "\"";
580}
581
582void TextNodeDumper::visitVerbatimLineComment(
583    const comments::VerbatimLineComment *C, const comments::FullComment *) {
584  OS << " Text=\"" << C->getText() << "\"";
585}
586
587void TextNodeDumper::VisitNullTemplateArgument(const TemplateArgument &) {
588  OS << " null";
589}
590
591void TextNodeDumper::VisitTypeTemplateArgument(const TemplateArgument &TA) {
592  OS << " type";
593  dumpType(TA.getAsType());
594}
595
596void TextNodeDumper::VisitDeclarationTemplateArgument(
597    const TemplateArgument &TA) {
598  OS << " decl";
599  dumpDeclRef(TA.getAsDecl());
600}
601
602void TextNodeDumper::VisitNullPtrTemplateArgument(const TemplateArgument &) {
603  OS << " nullptr";
604}
605
606void TextNodeDumper::VisitIntegralTemplateArgument(const TemplateArgument &TA) {
607  OS << " integral " << TA.getAsIntegral();
608}
609
610void TextNodeDumper::VisitTemplateTemplateArgument(const TemplateArgument &TA) {
611  OS << " template ";
612  TA.getAsTemplate().dump(OS);
613}
614
615void TextNodeDumper::VisitTemplateExpansionTemplateArgument(
616    const TemplateArgument &TA) {
617  OS << " template expansion ";
618  TA.getAsTemplateOrTemplatePattern().dump(OS);
619}
620
621void TextNodeDumper::VisitExpressionTemplateArgument(const TemplateArgument &) {
622  OS << " expr";
623}
624
625void TextNodeDumper::VisitPackTemplateArgument(const TemplateArgument &) {
626  OS << " pack";
627}
628
629static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {
630  if (Node->path_empty())
631    return;
632
633  OS << " (";
634  bool First = true;
635  for (CastExpr::path_const_iterator I = Node->path_begin(),
636                                     E = Node->path_end();
637       I != E; ++I) {
638    const CXXBaseSpecifier *Base = *I;
639    if (!First)
640      OS << " -> ";
641
642    const CXXRecordDecl *RD =
643        cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
644
645    if (Base->isVirtual())
646      OS << "virtual ";
647    OS << RD->getName();
648    First = false;
649  }
650
651  OS << ')';
652}
653
654void TextNodeDumper::VisitIfStmt(const IfStmt *Node) {
655  if (Node->hasInitStorage())
656    OS << " has_init";
657  if (Node->hasVarStorage())
658    OS << " has_var";
659  if (Node->hasElseStorage())
660    OS << " has_else";
661}
662
663void TextNodeDumper::VisitSwitchStmt(const SwitchStmt *Node) {
664  if (Node->hasInitStorage())
665    OS << " has_init";
666  if (Node->hasVarStorage())
667    OS << " has_var";
668}
669
670void TextNodeDumper::VisitWhileStmt(const WhileStmt *Node) {
671  if (Node->hasVarStorage())
672    OS << " has_var";
673}
674
675void TextNodeDumper::VisitLabelStmt(const LabelStmt *Node) {
676  OS << " '" << Node->getName() << "'";
677}
678
679void TextNodeDumper::VisitGotoStmt(const GotoStmt *Node) {
680  OS << " '" << Node->getLabel()->getName() << "'";
681  dumpPointer(Node->getLabel());
682}
683
684void TextNodeDumper::VisitCaseStmt(const CaseStmt *Node) {
685  if (Node->caseStmtIsGNURange())
686    OS << " gnu_range";
687}
688
689void TextNodeDumper::VisitCallExpr(const CallExpr *Node) {
690  if (Node->usesADL())
691    OS << " adl";
692}
693
694void TextNodeDumper::VisitCastExpr(const CastExpr *Node) {
695  OS << " <";
696  {
697    ColorScope Color(OS, ShowColors, CastColor);
698    OS << Node->getCastKindName();
699  }
700  dumpBasePath(OS, Node);
701  OS << ">";
702}
703
704void TextNodeDumper::VisitImplicitCastExpr(const ImplicitCastExpr *Node) {
705  VisitCastExpr(Node);
706  if (Node->isPartOfExplicitCast())
707    OS << " part_of_explicit_cast";
708}
709
710void TextNodeDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
711  OS << " ";
712  dumpBareDeclRef(Node->getDecl());
713  if (Node->getDecl() != Node->getFoundDecl()) {
714    OS << " (";
715    dumpBareDeclRef(Node->getFoundDecl());
716    OS << ")";
717  }
718}
719
720void TextNodeDumper::VisitUnresolvedLookupExpr(
721    const UnresolvedLookupExpr *Node) {
722  OS << " (";
723  if (!Node->requiresADL())
724    OS << "no ";
725  OS << "ADL) = '" << Node->getName() << '\'';
726
727  UnresolvedLookupExpr::decls_iterator I = Node->decls_begin(),
728                                       E = Node->decls_end();
729  if (I == E)
730    OS << " empty";
731  for (; I != E; ++I)
732    dumpPointer(*I);
733}
734
735void TextNodeDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
736  {
737    ColorScope Color(OS, ShowColors, DeclKindNameColor);
738    OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
739  }
740  OS << "='" << *Node->getDecl() << "'";
741  dumpPointer(Node->getDecl());
742  if (Node->isFreeIvar())
743    OS << " isFreeIvar";
744}
745
746void TextNodeDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
747  OS << " " << PredefinedExpr::getIdentKindName(Node->getIdentKind());
748}
749
750void TextNodeDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
751  ColorScope Color(OS, ShowColors, ValueColor);
752  OS << " " << Node->getValue();
753}
754
755void TextNodeDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {
756  bool isSigned = Node->getType()->isSignedIntegerType();
757  ColorScope Color(OS, ShowColors, ValueColor);
758  OS << " " << Node->getValue().toString(10, isSigned);
759}
760
761void TextNodeDumper::VisitFixedPointLiteral(const FixedPointLiteral *Node) {
762  ColorScope Color(OS, ShowColors, ValueColor);
763  OS << " " << Node->getValueAsString(/*Radix=*/10);
764}
765
766void TextNodeDumper::VisitFloatingLiteral(const FloatingLiteral *Node) {
767  ColorScope Color(OS, ShowColors, ValueColor);
768  OS << " " << Node->getValueAsApproximateDouble();
769}
770
771void TextNodeDumper::VisitStringLiteral(const StringLiteral *Str) {
772  ColorScope Color(OS, ShowColors, ValueColor);
773  OS << " ";
774  Str->outputString(OS);
775}
776
777void TextNodeDumper::VisitInitListExpr(const InitListExpr *ILE) {
778  if (auto *Field = ILE->getInitializedFieldInUnion()) {
779    OS << " field ";
780    dumpBareDeclRef(Field);
781  }
782}
783
784void TextNodeDumper::VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
785  if (E->isResultDependent())
786    OS << " result_dependent";
787}
788
789void TextNodeDumper::VisitUnaryOperator(const UnaryOperator *Node) {
790  OS << " " << (Node->isPostfix() ? "postfix" : "prefix") << " '"
791     << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
792  if (!Node->canOverflow())
793    OS << " cannot overflow";
794}
795
796void TextNodeDumper::VisitUnaryExprOrTypeTraitExpr(
797    const UnaryExprOrTypeTraitExpr *Node) {
798  switch (Node->getKind()) {
799  case UETT_SizeOf:
800    OS << " sizeof";
801    break;
802  case UETT_AlignOf:
803    OS << " alignof";
804    break;
805  case UETT_VecStep:
806    OS << " vec_step";
807    break;
808  case UETT_OpenMPRequiredSimdAlign:
809    OS << " __builtin_omp_required_simd_align";
810    break;
811  case UETT_PreferredAlignOf:
812    OS << " __alignof";
813    break;
814  }
815  if (Node->isArgumentType())
816    dumpType(Node->getArgumentType());
817}
818
819void TextNodeDumper::VisitMemberExpr(const MemberExpr *Node) {
820  OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
821  dumpPointer(Node->getMemberDecl());
822}
823
824void TextNodeDumper::VisitExtVectorElementExpr(
825    const ExtVectorElementExpr *Node) {
826  OS << " " << Node->getAccessor().getNameStart();
827}
828
829void TextNodeDumper::VisitBinaryOperator(const BinaryOperator *Node) {
830  OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
831}
832
833void TextNodeDumper::VisitCompoundAssignOperator(
834    const CompoundAssignOperator *Node) {
835  OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
836     << "' ComputeLHSTy=";
837  dumpBareType(Node->getComputationLHSType());
838  OS << " ComputeResultTy=";
839  dumpBareType(Node->getComputationResultType());
840}
841
842void TextNodeDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
843  OS << " " << Node->getLabel()->getName();
844  dumpPointer(Node->getLabel());
845}
846
847void TextNodeDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
848  OS << " " << Node->getCastName() << "<"
849     << Node->getTypeAsWritten().getAsString() << ">"
850     << " <" << Node->getCastKindName();
851  dumpBasePath(OS, Node);
852  OS << ">";
853}
854
855void TextNodeDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) {
856  OS << " " << (Node->getValue() ? "true" : "false");
857}
858
859void TextNodeDumper::VisitCXXThisExpr(const CXXThisExpr *Node) {
860  if (Node->isImplicit())
861    OS << " implicit";
862  OS << " this";
863}
864
865void TextNodeDumper::VisitCXXFunctionalCastExpr(
866    const CXXFunctionalCastExpr *Node) {
867  OS << " functional cast to " << Node->getTypeAsWritten().getAsString() << " <"
868     << Node->getCastKindName() << ">";
869}
870
871void TextNodeDumper::VisitCXXUnresolvedConstructExpr(
872    const CXXUnresolvedConstructExpr *Node) {
873  dumpType(Node->getTypeAsWritten());
874  if (Node->isListInitialization())
875    OS << " list";
876}
877
878void TextNodeDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
879  CXXConstructorDecl *Ctor = Node->getConstructor();
880  dumpType(Ctor->getType());
881  if (Node->isElidable())
882    OS << " elidable";
883  if (Node->isListInitialization())
884    OS << " list";
885  if (Node->isStdInitListInitialization())
886    OS << " std::initializer_list";
887  if (Node->requiresZeroInitialization())
888    OS << " zeroing";
889}
890
891void TextNodeDumper::VisitCXXBindTemporaryExpr(
892    const CXXBindTemporaryExpr *Node) {
893  OS << " ";
894  dumpCXXTemporary(Node->getTemporary());
895}
896
897void TextNodeDumper::VisitCXXNewExpr(const CXXNewExpr *Node) {
898  if (Node->isGlobalNew())
899    OS << " global";
900  if (Node->isArray())
901    OS << " array";
902  if (Node->getOperatorNew()) {
903    OS << ' ';
904    dumpBareDeclRef(Node->getOperatorNew());
905  }
906  // We could dump the deallocation function used in case of error, but it's
907  // usually not that interesting.
908}
909
910void TextNodeDumper::VisitCXXDeleteExpr(const CXXDeleteExpr *Node) {
911  if (Node->isGlobalDelete())
912    OS << " global";
913  if (Node->isArrayForm())
914    OS << " array";
915  if (Node->getOperatorDelete()) {
916    OS << ' ';
917    dumpBareDeclRef(Node->getOperatorDelete());
918  }
919}
920
921void TextNodeDumper::VisitMaterializeTemporaryExpr(
922    const MaterializeTemporaryExpr *Node) {
923  if (const ValueDecl *VD = Node->getExtendingDecl()) {
924    OS << " extended by ";
925    dumpBareDeclRef(VD);
926  }
927}
928
929void TextNodeDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
930  for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
931    dumpDeclRef(Node->getObject(i), "cleanup");
932}
933
934void TextNodeDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
935  dumpPointer(Node->getPack());
936  dumpName(Node->getPack());
937}
938
939void TextNodeDumper::VisitCXXDependentScopeMemberExpr(
940    const CXXDependentScopeMemberExpr *Node) {
941  OS << " " << (Node->isArrow() ? "->" : ".") << Node->getMember();
942}
943
944void TextNodeDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
945  OS << " selector=";
946  Node->getSelector().print(OS);
947  switch (Node->getReceiverKind()) {
948  case ObjCMessageExpr::Instance:
949    break;
950
951  case ObjCMessageExpr::Class:
952    OS << " class=";
953    dumpBareType(Node->getClassReceiver());
954    break;
955
956  case ObjCMessageExpr::SuperInstance:
957    OS << " super (instance)";
958    break;
959
960  case ObjCMessageExpr::SuperClass:
961    OS << " super (class)";
962    break;
963  }
964}
965
966void TextNodeDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
967  if (auto *BoxingMethod = Node->getBoxingMethod()) {
968    OS << " selector=";
969    BoxingMethod->getSelector().print(OS);
970  }
971}
972
973void TextNodeDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
974  if (!Node->getCatchParamDecl())
975    OS << " catch all";
976}
977
978void TextNodeDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
979  dumpType(Node->getEncodedType());
980}
981
982void TextNodeDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
983  OS << " ";
984  Node->getSelector().print(OS);
985}
986
987void TextNodeDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) {
988  OS << ' ' << *Node->getProtocol();
989}
990
991void TextNodeDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) {
992  if (Node->isImplicitProperty()) {
993    OS << " Kind=MethodRef Getter=\"";
994    if (Node->getImplicitPropertyGetter())
995      Node->getImplicitPropertyGetter()->getSelector().print(OS);
996    else
997      OS << "(null)";
998
999    OS << "\" Setter=\"";
1000    if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter())
1001      Setter->getSelector().print(OS);
1002    else
1003      OS << "(null)";
1004    OS << "\"";
1005  } else {
1006    OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty()
1007       << '"';
1008  }
1009
1010  if (Node->isSuperReceiver())
1011    OS << " super";
1012
1013  OS << " Messaging=";
1014  if (Node->isMessagingGetter() && Node->isMessagingSetter())
1015    OS << "Getter&Setter";
1016  else if (Node->isMessagingGetter())
1017    OS << "Getter";
1018  else if (Node->isMessagingSetter())
1019    OS << "Setter";
1020}
1021
1022void TextNodeDumper::VisitObjCSubscriptRefExpr(
1023    const ObjCSubscriptRefExpr *Node) {
1024  if (Node->isArraySubscriptRefExpr())
1025    OS << " Kind=ArraySubscript GetterForArray=\"";
1026  else
1027    OS << " Kind=DictionarySubscript GetterForDictionary=\"";
1028  if (Node->getAtIndexMethodDecl())
1029    Node->getAtIndexMethodDecl()->getSelector().print(OS);
1030  else
1031    OS << "(null)";
1032
1033  if (Node->isArraySubscriptRefExpr())
1034    OS << "\" SetterForArray=\"";
1035  else
1036    OS << "\" SetterForDictionary=\"";
1037  if (Node->setAtIndexMethodDecl())
1038    Node->setAtIndexMethodDecl()->getSelector().print(OS);
1039  else
1040    OS << "(null)";
1041}
1042
1043void TextNodeDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) {
1044  OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no");
1045}
1046
1047void TextNodeDumper::VisitRValueReferenceType(const ReferenceType *T) {
1048  if (T->isSpelledAsLValue())
1049    OS << " written as lvalue reference";
1050}
1051
1052void TextNodeDumper::VisitArrayType(const ArrayType *T) {
1053  switch (T->getSizeModifier()) {
1054  case ArrayType::Normal:
1055    break;
1056  case ArrayType::Static:
1057    OS << " static";
1058    break;
1059  case ArrayType::Star:
1060    OS << " *";
1061    break;
1062  }
1063  OS << " " << T->getIndexTypeQualifiers().getAsString();
1064}
1065
1066void TextNodeDumper::VisitConstantArrayType(const ConstantArrayType *T) {
1067  OS << " " << T->getSize();
1068  VisitArrayType(T);
1069}
1070
1071void TextNodeDumper::VisitVariableArrayType(const VariableArrayType *T) {
1072  OS << " ";
1073  dumpSourceRange(T->getBracketsRange());
1074  VisitArrayType(T);
1075}
1076
1077void TextNodeDumper::VisitDependentSizedArrayType(
1078    const DependentSizedArrayType *T) {
1079  VisitArrayType(T);
1080  OS << " ";
1081  dumpSourceRange(T->getBracketsRange());
1082}
1083
1084void TextNodeDumper::VisitDependentSizedExtVectorType(
1085    const DependentSizedExtVectorType *T) {
1086  OS << " ";
1087  dumpLocation(T->getAttributeLoc());
1088}
1089
1090void TextNodeDumper::VisitVectorType(const VectorType *T) {
1091  switch (T->getVectorKind()) {
1092  case VectorType::GenericVector:
1093    break;
1094  case VectorType::AltiVecVector:
1095    OS << " altivec";
1096    break;
1097  case VectorType::AltiVecPixel:
1098    OS << " altivec pixel";
1099    break;
1100  case VectorType::AltiVecBool:
1101    OS << " altivec bool";
1102    break;
1103  case VectorType::NeonVector:
1104    OS << " neon";
1105    break;
1106  case VectorType::NeonPolyVector:
1107    OS << " neon poly";
1108    break;
1109  }
1110  OS << " " << T->getNumElements();
1111}
1112
1113void TextNodeDumper::VisitFunctionType(const FunctionType *T) {
1114  auto EI = T->getExtInfo();
1115  if (EI.getNoReturn())
1116    OS << " noreturn";
1117  if (EI.getProducesResult())
1118    OS << " produces_result";
1119  if (EI.getHasRegParm())
1120    OS << " regparm " << EI.getRegParm();
1121  OS << " " << FunctionType::getNameForCallConv(EI.getCC());
1122}
1123
1124void TextNodeDumper::VisitFunctionProtoType(const FunctionProtoType *T) {
1125  auto EPI = T->getExtProtoInfo();
1126  if (EPI.HasTrailingReturn)
1127    OS << " trailing_return";
1128  if (T->isConst())
1129    OS << " const";
1130  if (T->isVolatile())
1131    OS << " volatile";
1132  if (T->isRestrict())
1133    OS << " restrict";
1134  if (T->getExtProtoInfo().Variadic)
1135    OS << " variadic";
1136  switch (EPI.RefQualifier) {
1137  case RQ_None:
1138    break;
1139  case RQ_LValue:
1140    OS << " &";
1141    break;
1142  case RQ_RValue:
1143    OS << " &&";
1144    break;
1145  }
1146  // FIXME: Exception specification.
1147  // FIXME: Consumed parameters.
1148  VisitFunctionType(T);
1149}
1150
1151void TextNodeDumper::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
1152  dumpDeclRef(T->getDecl());
1153}
1154
1155void TextNodeDumper::VisitTypedefType(const TypedefType *T) {
1156  dumpDeclRef(T->getDecl());
1157}
1158
1159void TextNodeDumper::VisitUnaryTransformType(const UnaryTransformType *T) {
1160  switch (T->getUTTKind()) {
1161  case UnaryTransformType::EnumUnderlyingType:
1162    OS << " underlying_type";
1163    break;
1164  }
1165}
1166
1167void TextNodeDumper::VisitTagType(const TagType *T) {
1168  dumpDeclRef(T->getDecl());
1169}
1170
1171void TextNodeDumper::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
1172  OS << " depth " << T->getDepth() << " index " << T->getIndex();
1173  if (T->isParameterPack())
1174    OS << " pack";
1175  dumpDeclRef(T->getDecl());
1176}
1177
1178void TextNodeDumper::VisitAutoType(const AutoType *T) {
1179  if (T->isDecltypeAuto())
1180    OS << " decltype(auto)";
1181  if (!T->isDeduced())
1182    OS << " undeduced";
1183}
1184
1185void TextNodeDumper::VisitTemplateSpecializationType(
1186    const TemplateSpecializationType *T) {
1187  if (T->isTypeAlias())
1188    OS << " alias";
1189  OS << " ";
1190  T->getTemplateName().dump(OS);
1191}
1192
1193void TextNodeDumper::VisitInjectedClassNameType(
1194    const InjectedClassNameType *T) {
1195  dumpDeclRef(T->getDecl());
1196}
1197
1198void TextNodeDumper::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1199  dumpDeclRef(T->getDecl());
1200}
1201
1202void TextNodeDumper::VisitPackExpansionType(const PackExpansionType *T) {
1203  if (auto N = T->getNumExpansions())
1204    OS << " expansions " << *N;
1205}
1206
1207void TextNodeDumper::VisitLabelDecl(const LabelDecl *D) { dumpName(D); }
1208
1209void TextNodeDumper::VisitTypedefDecl(const TypedefDecl *D) {
1210  dumpName(D);
1211  dumpType(D->getUnderlyingType());
1212  if (D->isModulePrivate())
1213    OS << " __module_private__";
1214}
1215
1216void TextNodeDumper::VisitEnumDecl(const EnumDecl *D) {
1217  if (D->isScoped()) {
1218    if (D->isScopedUsingClassTag())
1219      OS << " class";
1220    else
1221      OS << " struct";
1222  }
1223  dumpName(D);
1224  if (D->isModulePrivate())
1225    OS << " __module_private__";
1226  if (D->isFixed())
1227    dumpType(D->getIntegerType());
1228}
1229
1230void TextNodeDumper::VisitRecordDecl(const RecordDecl *D) {
1231  OS << ' ' << D->getKindName();
1232  dumpName(D);
1233  if (D->isModulePrivate())
1234    OS << " __module_private__";
1235  if (D->isCompleteDefinition())
1236    OS << " definition";
1237}
1238
1239void TextNodeDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
1240  dumpName(D);
1241  dumpType(D->getType());
1242}
1243
1244void TextNodeDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
1245  dumpName(D);
1246  dumpType(D->getType());
1247
1248  for (const auto *Child : D->chain())
1249    dumpDeclRef(Child);
1250}
1251
1252void TextNodeDumper::VisitFunctionDecl(const FunctionDecl *D) {
1253  dumpName(D);
1254  dumpType(D->getType());
1255
1256  StorageClass SC = D->getStorageClass();
1257  if (SC != SC_None)
1258    OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
1259  if (D->isInlineSpecified())
1260    OS << " inline";
1261  if (D->isVirtualAsWritten())
1262    OS << " virtual";
1263  if (D->isModulePrivate())
1264    OS << " __module_private__";
1265
1266  if (D->isPure())
1267    OS << " pure";
1268  if (D->isDefaulted()) {
1269    OS << " default";
1270    if (D->isDeleted())
1271      OS << "_delete";
1272  }
1273  if (D->isDeletedAsWritten())
1274    OS << " delete";
1275  if (D->isTrivial())
1276    OS << " trivial";
1277
1278  if (const auto *FPT = D->getType()->getAs<FunctionProtoType>()) {
1279    FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
1280    switch (EPI.ExceptionSpec.Type) {
1281    default:
1282      break;
1283    case EST_Unevaluated:
1284      OS << " noexcept-unevaluated " << EPI.ExceptionSpec.SourceDecl;
1285      break;
1286    case EST_Uninstantiated:
1287      OS << " noexcept-uninstantiated " << EPI.ExceptionSpec.SourceTemplate;
1288      break;
1289    }
1290  }
1291
1292  if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
1293    if (MD->size_overridden_methods() != 0) {
1294      auto dumpOverride = [=](const CXXMethodDecl *D) {
1295        SplitQualType T_split = D->getType().split();
1296        OS << D << " " << D->getParent()->getName()
1297           << "::" << D->getNameAsString() << " '"
1298           << QualType::getAsString(T_split, PrintPolicy) << "'";
1299      };
1300
1301      AddChild([=] {
1302        auto Overrides = MD->overridden_methods();
1303        OS << "Overrides: [ ";
1304        dumpOverride(*Overrides.begin());
1305        for (const auto *Override :
1306             llvm::make_range(Overrides.begin() + 1, Overrides.end())) {
1307          OS << ", ";
1308          dumpOverride(Override);
1309        }
1310        OS << " ]";
1311      });
1312    }
1313  }
1314
1315  // Since NumParams comes from the FunctionProtoType of the FunctionDecl and
1316  // the Params are set later, it is possible for a dump during debugging to
1317  // encounter a FunctionDecl that has been created but hasn't been assigned
1318  // ParmVarDecls yet.
1319  if (!D->param_empty() && !D->param_begin())
1320    OS << " <<<NULL params x " << D->getNumParams() << ">>>";
1321}
1322
1323void TextNodeDumper::VisitFieldDecl(const FieldDecl *D) {
1324  dumpName(D);
1325  dumpType(D->getType());
1326  if (D->isMutable())
1327    OS << " mutable";
1328  if (D->isModulePrivate())
1329    OS << " __module_private__";
1330}
1331
1332void TextNodeDumper::VisitVarDecl(const VarDecl *D) {
1333  dumpName(D);
1334  dumpType(D->getType());
1335  StorageClass SC = D->getStorageClass();
1336  if (SC != SC_None)
1337    OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
1338  switch (D->getTLSKind()) {
1339  case VarDecl::TLS_None:
1340    break;
1341  case VarDecl::TLS_Static:
1342    OS << " tls";
1343    break;
1344  case VarDecl::TLS_Dynamic:
1345    OS << " tls_dynamic";
1346    break;
1347  }
1348  if (D->isModulePrivate())
1349    OS << " __module_private__";
1350  if (D->isNRVOVariable())
1351    OS << " nrvo";
1352  if (D->isInline())
1353    OS << " inline";
1354  if (D->isConstexpr())
1355    OS << " constexpr";
1356  if (D->hasInit()) {
1357    switch (D->getInitStyle()) {
1358    case VarDecl::CInit:
1359      OS << " cinit";
1360      break;
1361    case VarDecl::CallInit:
1362      OS << " callinit";
1363      break;
1364    case VarDecl::ListInit:
1365      OS << " listinit";
1366      break;
1367    }
1368  }
1369}
1370
1371void TextNodeDumper::VisitBindingDecl(const BindingDecl *D) {
1372  dumpName(D);
1373  dumpType(D->getType());
1374}
1375
1376void TextNodeDumper::VisitCapturedDecl(const CapturedDecl *D) {
1377  if (D->isNothrow())
1378    OS << " nothrow";
1379}
1380
1381void TextNodeDumper::VisitImportDecl(const ImportDecl *D) {
1382  OS << ' ' << D->getImportedModule()->getFullModuleName();
1383
1384  for (Decl *InitD :
1385       D->getASTContext().getModuleInitializers(D->getImportedModule()))
1386    dumpDeclRef(InitD, "initializer");
1387}
1388
1389void TextNodeDumper::VisitPragmaCommentDecl(const PragmaCommentDecl *D) {
1390  OS << ' ';
1391  switch (D->getCommentKind()) {
1392  case PCK_Unknown:
1393    llvm_unreachable("unexpected pragma comment kind");
1394  case PCK_Compiler:
1395    OS << "compiler";
1396    break;
1397  case PCK_ExeStr:
1398    OS << "exestr";
1399    break;
1400  case PCK_Lib:
1401    OS << "lib";
1402    break;
1403  case PCK_Linker:
1404    OS << "linker";
1405    break;
1406  case PCK_User:
1407    OS << "user";
1408    break;
1409  }
1410  StringRef Arg = D->getArg();
1411  if (!Arg.empty())
1412    OS << " \"" << Arg << "\"";
1413}
1414
1415void TextNodeDumper::VisitPragmaDetectMismatchDecl(
1416    const PragmaDetectMismatchDecl *D) {
1417  OS << " \"" << D->getName() << "\" \"" << D->getValue() << "\"";
1418}
1419
1420void TextNodeDumper::VisitOMPExecutableDirective(
1421    const OMPExecutableDirective *D) {
1422  if (D->isStandaloneDirective())
1423    OS << " openmp_standalone_directive";
1424}
1425
1426void TextNodeDumper::VisitOMPDeclareReductionDecl(
1427    const OMPDeclareReductionDecl *D) {
1428  dumpName(D);
1429  dumpType(D->getType());
1430  OS << " combiner";
1431  dumpPointer(D->getCombiner());
1432  if (const auto *Initializer = D->getInitializer()) {
1433    OS << " initializer";
1434    dumpPointer(Initializer);
1435    switch (D->getInitializerKind()) {
1436    case OMPDeclareReductionDecl::DirectInit:
1437      OS << " omp_priv = ";
1438      break;
1439    case OMPDeclareReductionDecl::CopyInit:
1440      OS << " omp_priv ()";
1441      break;
1442    case OMPDeclareReductionDecl::CallInit:
1443      break;
1444    }
1445  }
1446}
1447
1448void TextNodeDumper::VisitOMPRequiresDecl(const OMPRequiresDecl *D) {
1449  for (const auto *C : D->clauselists()) {
1450    AddChild([=] {
1451      if (!C) {
1452        ColorScope Color(OS, ShowColors, NullColor);
1453        OS << "<<<NULL>>> OMPClause";
1454        return;
1455      }
1456      {
1457        ColorScope Color(OS, ShowColors, AttrColor);
1458        StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
1459        OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
1460           << ClauseName.drop_front() << "Clause";
1461      }
1462      dumpPointer(C);
1463      dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
1464    });
1465  }
1466}
1467
1468void TextNodeDumper::VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) {
1469  dumpName(D);
1470  dumpType(D->getType());
1471}
1472
1473void TextNodeDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
1474  dumpName(D);
1475  if (D->isInline())
1476    OS << " inline";
1477  if (!D->isOriginalNamespace())
1478    dumpDeclRef(D->getOriginalNamespace(), "original");
1479}
1480
1481void TextNodeDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
1482  OS << ' ';
1483  dumpBareDeclRef(D->getNominatedNamespace());
1484}
1485
1486void TextNodeDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
1487  dumpName(D);
1488  dumpDeclRef(D->getAliasedNamespace());
1489}
1490
1491void TextNodeDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
1492  dumpName(D);
1493  dumpType(D->getUnderlyingType());
1494}
1495
1496void TextNodeDumper::VisitTypeAliasTemplateDecl(
1497    const TypeAliasTemplateDecl *D) {
1498  dumpName(D);
1499}
1500
1501void TextNodeDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
1502  VisitRecordDecl(D);
1503  if (!D->isCompleteDefinition())
1504    return;
1505
1506  AddChild([=] {
1507    {
1508      ColorScope Color(OS, ShowColors, DeclKindNameColor);
1509      OS << "DefinitionData";
1510    }
1511#define FLAG(fn, name)                                                         \
1512  if (D->fn())                                                                 \
1513    OS << " " #name;
1514    FLAG(isParsingBaseSpecifiers, parsing_base_specifiers);
1515
1516    FLAG(isGenericLambda, generic);
1517    FLAG(isLambda, lambda);
1518
1519    FLAG(canPassInRegisters, pass_in_registers);
1520    FLAG(isEmpty, empty);
1521    FLAG(isAggregate, aggregate);
1522    FLAG(isStandardLayout, standard_layout);
1523    FLAG(isTriviallyCopyable, trivially_copyable);
1524    FLAG(isPOD, pod);
1525    FLAG(isTrivial, trivial);
1526    FLAG(isPolymorphic, polymorphic);
1527    FLAG(isAbstract, abstract);
1528    FLAG(isLiteral, literal);
1529
1530    FLAG(hasUserDeclaredConstructor, has_user_declared_ctor);
1531    FLAG(hasConstexprNonCopyMoveConstructor, has_constexpr_non_copy_move_ctor);
1532    FLAG(hasMutableFields, has_mutable_fields);
1533    FLAG(hasVariantMembers, has_variant_members);
1534    FLAG(allowConstDefaultInit, can_const_default_init);
1535
1536    AddChild([=] {
1537      {
1538        ColorScope Color(OS, ShowColors, DeclKindNameColor);
1539        OS << "DefaultConstructor";
1540      }
1541      FLAG(hasDefaultConstructor, exists);
1542      FLAG(hasTrivialDefaultConstructor, trivial);
1543      FLAG(hasNonTrivialDefaultConstructor, non_trivial);
1544      FLAG(hasUserProvidedDefaultConstructor, user_provided);
1545      FLAG(hasConstexprDefaultConstructor, constexpr);
1546      FLAG(needsImplicitDefaultConstructor, needs_implicit);
1547      FLAG(defaultedDefaultConstructorIsConstexpr, defaulted_is_constexpr);
1548    });
1549
1550    AddChild([=] {
1551      {
1552        ColorScope Color(OS, ShowColors, DeclKindNameColor);
1553        OS << "CopyConstructor";
1554      }
1555      FLAG(hasSimpleCopyConstructor, simple);
1556      FLAG(hasTrivialCopyConstructor, trivial);
1557      FLAG(hasNonTrivialCopyConstructor, non_trivial);
1558      FLAG(hasUserDeclaredCopyConstructor, user_declared);
1559      FLAG(hasCopyConstructorWithConstParam, has_const_param);
1560      FLAG(needsImplicitCopyConstructor, needs_implicit);
1561      FLAG(needsOverloadResolutionForCopyConstructor,
1562           needs_overload_resolution);
1563      if (!D->needsOverloadResolutionForCopyConstructor())
1564        FLAG(defaultedCopyConstructorIsDeleted, defaulted_is_deleted);
1565      FLAG(implicitCopyConstructorHasConstParam, implicit_has_const_param);
1566    });
1567
1568    AddChild([=] {
1569      {
1570        ColorScope Color(OS, ShowColors, DeclKindNameColor);
1571        OS << "MoveConstructor";
1572      }
1573      FLAG(hasMoveConstructor, exists);
1574      FLAG(hasSimpleMoveConstructor, simple);
1575      FLAG(hasTrivialMoveConstructor, trivial);
1576      FLAG(hasNonTrivialMoveConstructor, non_trivial);
1577      FLAG(hasUserDeclaredMoveConstructor, user_declared);
1578      FLAG(needsImplicitMoveConstructor, needs_implicit);
1579      FLAG(needsOverloadResolutionForMoveConstructor,
1580           needs_overload_resolution);
1581      if (!D->needsOverloadResolutionForMoveConstructor())
1582        FLAG(defaultedMoveConstructorIsDeleted, defaulted_is_deleted);
1583    });
1584
1585    AddChild([=] {
1586      {
1587        ColorScope Color(OS, ShowColors, DeclKindNameColor);
1588        OS << "CopyAssignment";
1589      }
1590      FLAG(hasTrivialCopyAssignment, trivial);
1591      FLAG(hasNonTrivialCopyAssignment, non_trivial);
1592      FLAG(hasCopyAssignmentWithConstParam, has_const_param);
1593      FLAG(hasUserDeclaredCopyAssignment, user_declared);
1594      FLAG(needsImplicitCopyAssignment, needs_implicit);
1595      FLAG(needsOverloadResolutionForCopyAssignment, needs_overload_resolution);
1596      FLAG(implicitCopyAssignmentHasConstParam, implicit_has_const_param);
1597    });
1598
1599    AddChild([=] {
1600      {
1601        ColorScope Color(OS, ShowColors, DeclKindNameColor);
1602        OS << "MoveAssignment";
1603      }
1604      FLAG(hasMoveAssignment, exists);
1605      FLAG(hasSimpleMoveAssignment, simple);
1606      FLAG(hasTrivialMoveAssignment, trivial);
1607      FLAG(hasNonTrivialMoveAssignment, non_trivial);
1608      FLAG(hasUserDeclaredMoveAssignment, user_declared);
1609      FLAG(needsImplicitMoveAssignment, needs_implicit);
1610      FLAG(needsOverloadResolutionForMoveAssignment, needs_overload_resolution);
1611    });
1612
1613    AddChild([=] {
1614      {
1615        ColorScope Color(OS, ShowColors, DeclKindNameColor);
1616        OS << "Destructor";
1617      }
1618      FLAG(hasSimpleDestructor, simple);
1619      FLAG(hasIrrelevantDestructor, irrelevant);
1620      FLAG(hasTrivialDestructor, trivial);
1621      FLAG(hasNonTrivialDestructor, non_trivial);
1622      FLAG(hasUserDeclaredDestructor, user_declared);
1623      FLAG(needsImplicitDestructor, needs_implicit);
1624      FLAG(needsOverloadResolutionForDestructor, needs_overload_resolution);
1625      if (!D->needsOverloadResolutionForDestructor())
1626        FLAG(defaultedDestructorIsDeleted, defaulted_is_deleted);
1627    });
1628  });
1629
1630  for (const auto &I : D->bases()) {
1631    AddChild([=] {
1632      if (I.isVirtual())
1633        OS << "virtual ";
1634      dumpAccessSpecifier(I.getAccessSpecifier());
1635      dumpType(I.getType());
1636      if (I.isPackExpansion())
1637        OS << "...";
1638    });
1639  }
1640}
1641
1642void TextNodeDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
1643  dumpName(D);
1644}
1645
1646void TextNodeDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
1647  dumpName(D);
1648}
1649
1650void TextNodeDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
1651  dumpName(D);
1652}
1653
1654void TextNodeDumper::VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) {
1655  dumpName(D);
1656}
1657
1658void TextNodeDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
1659  if (D->wasDeclaredWithTypename())
1660    OS << " typename";
1661  else
1662    OS << " class";
1663  OS << " depth " << D->getDepth() << " index " << D->getIndex();
1664  if (D->isParameterPack())
1665    OS << " ...";
1666  dumpName(D);
1667}
1668
1669void TextNodeDumper::VisitNonTypeTemplateParmDecl(
1670    const NonTypeTemplateParmDecl *D) {
1671  dumpType(D->getType());
1672  OS << " depth " << D->getDepth() << " index " << D->getIndex();
1673  if (D->isParameterPack())
1674    OS << " ...";
1675  dumpName(D);
1676}
1677
1678void TextNodeDumper::VisitTemplateTemplateParmDecl(
1679    const TemplateTemplateParmDecl *D) {
1680  OS << " depth " << D->getDepth() << " index " << D->getIndex();
1681  if (D->isParameterPack())
1682    OS << " ...";
1683  dumpName(D);
1684}
1685
1686void TextNodeDumper::VisitUsingDecl(const UsingDecl *D) {
1687  OS << ' ';
1688  if (D->getQualifier())
1689    D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1690  OS << D->getNameAsString();
1691}
1692
1693void TextNodeDumper::VisitUnresolvedUsingTypenameDecl(
1694    const UnresolvedUsingTypenameDecl *D) {
1695  OS << ' ';
1696  if (D->getQualifier())
1697    D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1698  OS << D->getNameAsString();
1699}
1700
1701void TextNodeDumper::VisitUnresolvedUsingValueDecl(
1702    const UnresolvedUsingValueDecl *D) {
1703  OS << ' ';
1704  if (D->getQualifier())
1705    D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1706  OS << D->getNameAsString();
1707  dumpType(D->getType());
1708}
1709
1710void TextNodeDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
1711  OS << ' ';
1712  dumpBareDeclRef(D->getTargetDecl());
1713}
1714
1715void TextNodeDumper::VisitConstructorUsingShadowDecl(
1716    const ConstructorUsingShadowDecl *D) {
1717  if (D->constructsVirtualBase())
1718    OS << " virtual";
1719
1720  AddChild([=] {
1721    OS << "target ";
1722    dumpBareDeclRef(D->getTargetDecl());
1723  });
1724
1725  AddChild([=] {
1726    OS << "nominated ";
1727    dumpBareDeclRef(D->getNominatedBaseClass());
1728    OS << ' ';
1729    dumpBareDeclRef(D->getNominatedBaseClassShadowDecl());
1730  });
1731
1732  AddChild([=] {
1733    OS << "constructed ";
1734    dumpBareDeclRef(D->getConstructedBaseClass());
1735    OS << ' ';
1736    dumpBareDeclRef(D->getConstructedBaseClassShadowDecl());
1737  });
1738}
1739
1740void TextNodeDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
1741  switch (D->getLanguage()) {
1742  case LinkageSpecDecl::lang_c:
1743    OS << " C";
1744    break;
1745  case LinkageSpecDecl::lang_cxx:
1746    OS << " C++";
1747    break;
1748  }
1749}
1750
1751void TextNodeDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
1752  OS << ' ';
1753  dumpAccessSpecifier(D->getAccess());
1754}
1755
1756void TextNodeDumper::VisitFriendDecl(const FriendDecl *D) {
1757  if (TypeSourceInfo *T = D->getFriendType())
1758    dumpType(T->getType());
1759}
1760
1761void TextNodeDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
1762  dumpName(D);
1763  dumpType(D->getType());
1764  if (D->getSynthesize())
1765    OS << " synthesize";
1766
1767  switch (D->getAccessControl()) {
1768  case ObjCIvarDecl::None:
1769    OS << " none";
1770    break;
1771  case ObjCIvarDecl::Private:
1772    OS << " private";
1773    break;
1774  case ObjCIvarDecl::Protected:
1775    OS << " protected";
1776    break;
1777  case ObjCIvarDecl::Public:
1778    OS << " public";
1779    break;
1780  case ObjCIvarDecl::Package:
1781    OS << " package";
1782    break;
1783  }
1784}
1785
1786void TextNodeDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
1787  if (D->isInstanceMethod())
1788    OS << " -";
1789  else
1790    OS << " +";
1791  dumpName(D);
1792  dumpType(D->getReturnType());
1793
1794  if (D->isVariadic())
1795    OS << " variadic";
1796}
1797
1798void TextNodeDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) {
1799  dumpName(D);
1800  switch (D->getVariance()) {
1801  case ObjCTypeParamVariance::Invariant:
1802    break;
1803
1804  case ObjCTypeParamVariance::Covariant:
1805    OS << " covariant";
1806    break;
1807
1808  case ObjCTypeParamVariance::Contravariant:
1809    OS << " contravariant";
1810    break;
1811  }
1812
1813  if (D->hasExplicitBound())
1814    OS << " bounded";
1815  dumpType(D->getUnderlyingType());
1816}
1817
1818void TextNodeDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
1819  dumpName(D);
1820  dumpDeclRef(D->getClassInterface());
1821  dumpDeclRef(D->getImplementation());
1822  for (const auto *P : D->protocols())
1823    dumpDeclRef(P);
1824}
1825
1826void TextNodeDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
1827  dumpName(D);
1828  dumpDeclRef(D->getClassInterface());
1829  dumpDeclRef(D->getCategoryDecl());
1830}
1831
1832void TextNodeDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
1833  dumpName(D);
1834
1835  for (const auto *Child : D->protocols())
1836    dumpDeclRef(Child);
1837}
1838
1839void TextNodeDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
1840  dumpName(D);
1841  dumpDeclRef(D->getSuperClass(), "super");
1842
1843  dumpDeclRef(D->getImplementation());
1844  for (const auto *Child : D->protocols())
1845    dumpDeclRef(Child);
1846}
1847
1848void TextNodeDumper::VisitObjCImplementationDecl(
1849    const ObjCImplementationDecl *D) {
1850  dumpName(D);
1851  dumpDeclRef(D->getSuperClass(), "super");
1852  dumpDeclRef(D->getClassInterface());
1853}
1854
1855void TextNodeDumper::VisitObjCCompatibleAliasDecl(
1856    const ObjCCompatibleAliasDecl *D) {
1857  dumpName(D);
1858  dumpDeclRef(D->getClassInterface());
1859}
1860
1861void TextNodeDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
1862  dumpName(D);
1863  dumpType(D->getType());
1864
1865  if (D->getPropertyImplementation() == ObjCPropertyDecl::Required)
1866    OS << " required";
1867  else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
1868    OS << " optional";
1869
1870  ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes();
1871  if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
1872    if (Attrs & ObjCPropertyDecl::OBJC_PR_readonly)
1873      OS << " readonly";
1874    if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
1875      OS << " assign";
1876    if (Attrs & ObjCPropertyDecl::OBJC_PR_readwrite)
1877      OS << " readwrite";
1878    if (Attrs & ObjCPropertyDecl::OBJC_PR_retain)
1879      OS << " retain";
1880    if (Attrs & ObjCPropertyDecl::OBJC_PR_copy)
1881      OS << " copy";
1882    if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic)
1883      OS << " nonatomic";
1884    if (Attrs & ObjCPropertyDecl::OBJC_PR_atomic)
1885      OS << " atomic";
1886    if (Attrs & ObjCPropertyDecl::OBJC_PR_weak)
1887      OS << " weak";
1888    if (Attrs & ObjCPropertyDecl::OBJC_PR_strong)
1889      OS << " strong";
1890    if (Attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained)
1891      OS << " unsafe_unretained";
1892    if (Attrs & ObjCPropertyDecl::OBJC_PR_class)
1893      OS << " class";
1894    if (Attrs & ObjCPropertyDecl::OBJC_PR_getter)
1895      dumpDeclRef(D->getGetterMethodDecl(), "getter");
1896    if (Attrs & ObjCPropertyDecl::OBJC_PR_setter)
1897      dumpDeclRef(D->getSetterMethodDecl(), "setter");
1898  }
1899}
1900
1901void TextNodeDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
1902  dumpName(D->getPropertyDecl());
1903  if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
1904    OS << " synthesize";
1905  else
1906    OS << " dynamic";
1907  dumpDeclRef(D->getPropertyDecl());
1908  dumpDeclRef(D->getPropertyIvarDecl());
1909}
1910
1911void TextNodeDumper::VisitBlockDecl(const BlockDecl *D) {
1912  if (D->isVariadic())
1913    OS << " variadic";
1914
1915  if (D->capturesCXXThis())
1916    OS << " captures_this";
1917}
1918
clang::TextNodeDumper::Visit
clang::TextNodeDumper::Visit
clang::TextNodeDumper::Visit
clang::TextNodeDumper::Visit
clang::TextNodeDumper::Visit
clang::TextNodeDumper::Visit
clang::TextNodeDumper::Visit
clang::TextNodeDumper::Visit
clang::TextNodeDumper::Visit
clang::TextNodeDumper::Visit
clang::TextNodeDumper::Visit
clang::TextNodeDumper::dumpPointer
clang::TextNodeDumper::dumpLocation
clang::TextNodeDumper::dumpSourceRange
clang::TextNodeDumper::dumpBareType
clang::TextNodeDumper::dumpType
clang::TextNodeDumper::dumpBareDeclRef
clang::TextNodeDumper::dumpName
clang::TextNodeDumper::dumpAccessSpecifier
clang::TextNodeDumper::dumpCXXTemporary
clang::TextNodeDumper::dumpDeclRef
clang::TextNodeDumper::getCommandName
clang::TextNodeDumper::visitTextComment
clang::TextNodeDumper::visitInlineCommandComment
clang::TextNodeDumper::visitHTMLStartTagComment
clang::TextNodeDumper::visitHTMLEndTagComment
clang::TextNodeDumper::visitBlockCommandComment
clang::TextNodeDumper::visitParamCommandComment
clang::TextNodeDumper::visitTParamCommandComment
clang::TextNodeDumper::visitVerbatimBlockComment
clang::TextNodeDumper::visitVerbatimBlockLineComment
clang::TextNodeDumper::visitVerbatimLineComment
clang::TextNodeDumper::VisitNullTemplateArgument
clang::TextNodeDumper::VisitTypeTemplateArgument
clang::TextNodeDumper::VisitDeclarationTemplateArgument
clang::TextNodeDumper::VisitNullPtrTemplateArgument
clang::TextNodeDumper::VisitIntegralTemplateArgument
clang::TextNodeDumper::VisitTemplateTemplateArgument
clang::TextNodeDumper::VisitTemplateExpansionTemplateArgument
clang::TextNodeDumper::VisitExpressionTemplateArgument
clang::TextNodeDumper::VisitPackTemplateArgument
clang::TextNodeDumper::VisitIfStmt
clang::TextNodeDumper::VisitSwitchStmt
clang::TextNodeDumper::VisitWhileStmt
clang::TextNodeDumper::VisitLabelStmt
clang::TextNodeDumper::VisitGotoStmt
clang::TextNodeDumper::VisitCaseStmt
clang::TextNodeDumper::VisitCallExpr
clang::TextNodeDumper::VisitCastExpr
clang::TextNodeDumper::VisitImplicitCastExpr
clang::TextNodeDumper::VisitDeclRefExpr
clang::TextNodeDumper::VisitUnresolvedLookupExpr
clang::TextNodeDumper::VisitObjCIvarRefExpr
clang::TextNodeDumper::VisitPredefinedExpr
clang::TextNodeDumper::VisitCharacterLiteral
clang::TextNodeDumper::VisitIntegerLiteral
clang::TextNodeDumper::VisitFixedPointLiteral
clang::TextNodeDumper::VisitFloatingLiteral
clang::TextNodeDumper::VisitStringLiteral
clang::TextNodeDumper::VisitInitListExpr
clang::TextNodeDumper::VisitGenericSelectionExpr
clang::TextNodeDumper::VisitUnaryOperator
clang::TextNodeDumper::VisitUnaryExprOrTypeTraitExpr
clang::TextNodeDumper::VisitMemberExpr
clang::TextNodeDumper::VisitExtVectorElementExpr
clang::TextNodeDumper::VisitBinaryOperator
clang::TextNodeDumper::VisitCompoundAssignOperator
clang::TextNodeDumper::VisitAddrLabelExpr
clang::TextNodeDumper::VisitCXXNamedCastExpr
clang::TextNodeDumper::VisitCXXBoolLiteralExpr
clang::TextNodeDumper::VisitCXXThisExpr
clang::TextNodeDumper::VisitCXXFunctionalCastExpr
clang::TextNodeDumper::VisitCXXUnresolvedConstructExpr
clang::TextNodeDumper::VisitCXXConstructExpr
clang::TextNodeDumper::VisitCXXBindTemporaryExpr
clang::TextNodeDumper::VisitCXXNewExpr
clang::TextNodeDumper::VisitCXXDeleteExpr
clang::TextNodeDumper::VisitMaterializeTemporaryExpr
clang::TextNodeDumper::VisitExprWithCleanups
clang::TextNodeDumper::VisitSizeOfPackExpr
clang::TextNodeDumper::VisitCXXDependentScopeMemberExpr
clang::TextNodeDumper::VisitObjCMessageExpr
clang::TextNodeDumper::VisitObjCBoxedExpr
clang::TextNodeDumper::VisitObjCAtCatchStmt
clang::TextNodeDumper::VisitObjCEncodeExpr
clang::TextNodeDumper::VisitObjCSelectorExpr
clang::TextNodeDumper::VisitObjCProtocolExpr
clang::TextNodeDumper::VisitObjCPropertyRefExpr
clang::TextNodeDumper::VisitObjCSubscriptRefExpr
clang::TextNodeDumper::VisitObjCBoolLiteralExpr
clang::TextNodeDumper::VisitRValueReferenceType
clang::TextNodeDumper::VisitArrayType
clang::TextNodeDumper::VisitConstantArrayType
clang::TextNodeDumper::VisitVariableArrayType
clang::TextNodeDumper::VisitDependentSizedArrayType
clang::TextNodeDumper::VisitDependentSizedExtVectorType
clang::TextNodeDumper::VisitVectorType
clang::TextNodeDumper::VisitFunctionType
clang::TextNodeDumper::VisitFunctionProtoType
clang::TextNodeDumper::VisitUnresolvedUsingType
clang::TextNodeDumper::VisitTypedefType
clang::TextNodeDumper::VisitUnaryTransformType
clang::TextNodeDumper::VisitTagType
clang::TextNodeDumper::VisitTemplateTypeParmType
clang::TextNodeDumper::VisitAutoType
clang::TextNodeDumper::VisitTemplateSpecializationType
clang::TextNodeDumper::VisitInjectedClassNameType
clang::TextNodeDumper::VisitObjCInterfaceType
clang::TextNodeDumper::VisitPackExpansionType
clang::TextNodeDumper::VisitLabelDecl
clang::TextNodeDumper::VisitTypedefDecl
clang::TextNodeDumper::VisitEnumDecl
clang::TextNodeDumper::VisitRecordDecl
clang::TextNodeDumper::VisitEnumConstantDecl
clang::TextNodeDumper::VisitIndirectFieldDecl
clang::TextNodeDumper::VisitFunctionDecl
clang::TextNodeDumper::VisitFieldDecl
clang::TextNodeDumper::VisitVarDecl
clang::TextNodeDumper::VisitBindingDecl
clang::TextNodeDumper::VisitCapturedDecl
clang::TextNodeDumper::VisitImportDecl
clang::TextNodeDumper::VisitPragmaCommentDecl
clang::TextNodeDumper::VisitPragmaDetectMismatchDecl
clang::TextNodeDumper::VisitOMPExecutableDirective
clang::TextNodeDumper::VisitOMPDeclareReductionDecl
clang::TextNodeDumper::VisitOMPRequiresDecl
clang::TextNodeDumper::VisitOMPCapturedExprDecl
clang::TextNodeDumper::VisitNamespaceDecl
clang::TextNodeDumper::VisitUsingDirectiveDecl
clang::TextNodeDumper::VisitNamespaceAliasDecl
clang::TextNodeDumper::VisitTypeAliasDecl
clang::TextNodeDumper::VisitTypeAliasTemplateDecl
clang::TextNodeDumper::VisitCXXRecordDecl
clang::TextNodeDumper::VisitFunctionTemplateDecl
clang::TextNodeDumper::VisitClassTemplateDecl
clang::TextNodeDumper::VisitVarTemplateDecl
clang::TextNodeDumper::VisitBuiltinTemplateDecl
clang::TextNodeDumper::VisitTemplateTypeParmDecl
clang::TextNodeDumper::VisitNonTypeTemplateParmDecl
clang::TextNodeDumper::VisitTemplateTemplateParmDecl
clang::TextNodeDumper::VisitUsingDecl
clang::TextNodeDumper::VisitUnresolvedUsingTypenameDecl
clang::TextNodeDumper::VisitUnresolvedUsingValueDecl
clang::TextNodeDumper::VisitUsingShadowDecl
clang::TextNodeDumper::VisitConstructorUsingShadowDecl
clang::TextNodeDumper::VisitLinkageSpecDecl
clang::TextNodeDumper::VisitAccessSpecDecl
clang::TextNodeDumper::VisitFriendDecl
clang::TextNodeDumper::VisitObjCIvarDecl
clang::TextNodeDumper::VisitObjCMethodDecl
clang::TextNodeDumper::VisitObjCTypeParamDecl
clang::TextNodeDumper::VisitObjCCategoryDecl
clang::TextNodeDumper::VisitObjCCategoryImplDecl
clang::TextNodeDumper::VisitObjCProtocolDecl
clang::TextNodeDumper::VisitObjCInterfaceDecl
clang::TextNodeDumper::VisitObjCImplementationDecl
clang::TextNodeDumper::VisitObjCCompatibleAliasDecl
clang::TextNodeDumper::VisitObjCPropertyDecl
clang::TextNodeDumper::VisitObjCPropertyImplDecl
clang::TextNodeDumper::VisitBlockDecl
CodeThinker, Enjoy your reading code