1//===--- ASTDumper.cpp - Dumping implementation for ASTs ------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the AST dump methods, which dump out the
11// AST in a form that exposes type details and other fields.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/Attr.h"
17#include "clang/AST/CommentVisitor.h"
18#include "clang/AST/DeclCXX.h"
19#include "clang/AST/DeclLookups.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/AST/DeclVisitor.h"
22#include "clang/AST/StmtVisitor.h"
23#include "clang/Basic/Module.h"
24#include "clang/Basic/SourceManager.h"
25#include "llvm/Support/raw_ostream.h"
26using namespace clang;
27using namespace clang::comments;
28
29//===----------------------------------------------------------------------===//
30// ASTDumper Visitor
31//===----------------------------------------------------------------------===//
32
33namespace  {
34  // Colors used for various parts of the AST dump
35  // Do not use bold yellow for any text.  It is hard to read on white screens.
36
37  struct TerminalColor {
38    raw_ostream::Colors Color;
39    bool Bold;
40  };
41
42  // Red           - CastColor
43  // Green         - TypeColor
44  // Bold Green    - DeclKindNameColor, UndeserializedColor
45  // Yellow        - AddressColor, LocationColor
46  // Blue          - CommentColor, NullColor, IndentColor
47  // Bold Blue     - AttrColor
48  // Bold Magenta  - StmtColor
49  // Cyan          - ValueKindColor, ObjectKindColor
50  // Bold Cyan     - ValueColor, DeclNameColor
51
52  // Decl kind names (VarDecl, FunctionDecl, etc)
53  static const TerminalColor DeclKindNameColor = { raw_ostream::GREEN, true };
54  // Attr names (CleanupAttr, GuardedByAttr, etc)
55  static const TerminalColor AttrColor = { raw_ostream::BLUE, true };
56  // Statement names (DeclStmt, ImplicitCastExpr, etc)
57  static const TerminalColor StmtColor = { raw_ostream::MAGENTA, true };
58  // Comment names (FullComment, ParagraphComment, TextComment, etc)
59  static const TerminalColor CommentColor = { raw_ostream::BLUE, false };
60
61  // Type names (int, float, etc, plus user defined types)
62  static const TerminalColor TypeColor = { raw_ostream::GREEN, false };
63
64  // Pointer address
65  static const TerminalColor AddressColor = { raw_ostream::YELLOW, false };
66  // Source locations
67  static const TerminalColor LocationColor = { raw_ostream::YELLOW, false };
68
69  // lvalue/xvalue
70  static const TerminalColor ValueKindColor = { raw_ostream::CYAN, false };
71  // bitfield/objcproperty/objcsubscript/vectorcomponent
72  static const TerminalColor ObjectKindColor = { raw_ostream::CYAN, false };
73
74  // Null statements
75  static const TerminalColor NullColor = { raw_ostream::BLUE, false };
76
77  // Undeserialized entities
78  static const TerminalColor UndeserializedColor = { raw_ostream::GREEN, true };
79
80  // CastKind from CastExpr's
81  static const TerminalColor CastColor = { raw_ostream::RED, false };
82
83  // Value of the statement
84  static const TerminalColor ValueColor = { raw_ostream::CYAN, true };
85  // Decl names
86  static const TerminalColor DeclNameColor = { raw_ostream::CYAN, true };
87
88  // Indents ( `, -. | )
89  static const TerminalColor IndentColor = { raw_ostream::BLUE, false };
90
91  class ASTDumper
92      : public ConstDeclVisitor<ASTDumper>, public ConstStmtVisitor<ASTDumper>,
93        public ConstCommentVisitor<ASTDumper> {
94    raw_ostream &OS;
95    const CommandTraits *Traits;
96    const SourceManager *SM;
97    bool IsFirstLine;
98
99    // Indicates whether more child are expected at the current tree depth
100    enum IndentType { IT_Child, IT_LastChild };
101
102    /// Indents[i] indicates if another child exists at level i.
103    /// Used by Indent() to print the tree structure.
104    llvm::SmallVector<IndentType, 32> Indents;
105
106    /// Indicates that more children will be needed at this indent level.
107    /// If true, prevents lastChild() from marking the node as the last child.
108    /// This is used when there are multiple collections of children to be
109    /// dumped as well as during conditional node dumping.
110    bool MoreChildren;
111
112    /// Keep track of the last location we print out so that we can
113    /// print out deltas from then on out.
114    const char *LastLocFilename;
115    unsigned LastLocLine;
116
117    /// The \c FullComment parent of the comment being dumped.
118    const FullComment *FC;
119
120    bool ShowColors;
121
122    class IndentScope {
123      ASTDumper &Dumper;
124      // Preserve the Dumper's MoreChildren value from the previous IndentScope
125      bool MoreChildren;
126    public:
127      IndentScope(ASTDumper &Dumper) : Dumper(Dumper) {
128        MoreChildren = Dumper.hasMoreChildren();
129        Dumper.setMoreChildren(false);
130        Dumper.indent();
131      }
132      ~IndentScope() {
133        Dumper.setMoreChildren(MoreChildren);
134        Dumper.unindent();
135      }
136    };
137
138    class ColorScope {
139      ASTDumper &Dumper;
140    public:
141      ColorScope(ASTDumper &Dumper, TerminalColor Color)
142        : Dumper(Dumper) {
143        if (Dumper.ShowColors)
144          Dumper.OS.changeColor(Color.Color, Color.Bold);
145      }
146      ~ColorScope() {
147        if (Dumper.ShowColors)
148          Dumper.OS.resetColor();
149      }
150    };
151
152    class ChildDumper {
153      ASTDumper &Dumper;
154
155      const Decl *Prev;
156      bool PrevRef;
157    public:
158      ChildDumper(ASTDumper &Dumper) : Dumper(Dumper), Prev(nullptr) {}
159      ~ChildDumper() {
160        if (Prev) {
161          Dumper.lastChild();
162          dump(nullptr);
163        }
164      }
165
166      // FIXME: This should take an arbitrary callable as the dumping action.
167      void dump(const Decl *D, bool Ref = false) {
168        if (Prev) {
169          if (PrevRef)
170            Dumper.dumpDeclRef(Prev);
171          else
172            Dumper.dumpDecl(Prev);
173        }
174        Prev = D;
175        PrevRef = Ref;
176      }
177      void dumpRef(const Decl *D) { dump(D, true); }
178
179      // Give up ownership of the children of the node. By calling this,
180      // the caller takes back responsibility for calling lastChild().
181      void release() { dump(nullptr); }
182    };
183
184  public:
185    ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
186              const SourceManager *SM)
187      : OS(OS), Traits(Traits), SM(SM), IsFirstLine(true), MoreChildren(false),
188        LastLocFilename(""), LastLocLine(~0U), FC(nullptr),
189        ShowColors(SM && SM->getDiagnostics().getShowColors()) { }
190
191    ASTDumper(raw_ostream &OS, const CommandTraits *Traits,
192              const SourceManager *SM, bool ShowColors)
193      : OS(OS), Traits(Traits), SM(SM), IsFirstLine(true), MoreChildren(false),
194        LastLocFilename(""), LastLocLine(~0U),
195        ShowColors(ShowColors) { }
196
197    ~ASTDumper() {
198      OS << "\n";
199    }
200
201    void dumpDecl(const Decl *D);
202    void dumpStmt(const Stmt *S);
203    void dumpFullComment(const FullComment *C);
204
205    // Formatting
206    void indent();
207    void unindent();
208    void lastChild();
209    bool hasMoreChildren();
210    void setMoreChildren(bool Value);
211
212    // Utilities
213    void dumpPointer(const void *Ptr);
214    void dumpSourceRange(SourceRange R);
215    void dumpLocation(SourceLocation Loc);
216    void dumpBareType(QualType T);
217    void dumpType(QualType T);
218    void dumpBareDeclRef(const Decl *Node);
219    void dumpDeclRef(const Decl *Node, const char *Label = nullptr);
220    void dumpName(const NamedDecl *D);
221    bool hasNodes(const DeclContext *DC);
222    void dumpDeclContext(const DeclContext *DC);
223    void dumpLookups(const DeclContext *DC);
224    void dumpAttr(const Attr *A);
225
226    // C++ Utilities
227    void dumpAccessSpecifier(AccessSpecifier AS);
228    void dumpCXXCtorInitializer(const CXXCtorInitializer *Init);
229    void dumpTemplateParameters(const TemplateParameterList *TPL);
230    void dumpTemplateArgumentListInfo(const TemplateArgumentListInfo &TALI);
231    void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A);
232    void dumpTemplateArgumentList(const TemplateArgumentList &TAL);
233    void dumpTemplateArgument(const TemplateArgument &A,
234                              SourceRange R = SourceRange());
235
236    // Decls
237    void VisitLabelDecl(const LabelDecl *D);
238    void VisitTypedefDecl(const TypedefDecl *D);
239    void VisitEnumDecl(const EnumDecl *D);
240    void VisitRecordDecl(const RecordDecl *D);
241    void VisitEnumConstantDecl(const EnumConstantDecl *D);
242    void VisitIndirectFieldDecl(const IndirectFieldDecl *D);
243    void VisitFunctionDecl(const FunctionDecl *D);
244    void VisitFieldDecl(const FieldDecl *D);
245    void VisitVarDecl(const VarDecl *D);
246    void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D);
247    void VisitImportDecl(const ImportDecl *D);
248
249    // C++ Decls
250    void VisitNamespaceDecl(const NamespaceDecl *D);
251    void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D);
252    void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D);
253    void VisitTypeAliasDecl(const TypeAliasDecl *D);
254    void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D);
255    void VisitCXXRecordDecl(const CXXRecordDecl *D);
256    void VisitStaticAssertDecl(const StaticAssertDecl *D);
257    template<typename SpecializationDecl>
258    void VisitTemplateDeclSpecialization(ChildDumper &Children,
259                                         const SpecializationDecl *D,
260                                         bool DumpExplicitInst,
261                                         bool DumpRefOnly);
262    template<typename TemplateDecl>
263    void VisitTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst);
264    void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D);
265    void VisitClassTemplateDecl(const ClassTemplateDecl *D);
266    void VisitClassTemplateSpecializationDecl(
267        const ClassTemplateSpecializationDecl *D);
268    void VisitClassTemplatePartialSpecializationDecl(
269        const ClassTemplatePartialSpecializationDecl *D);
270    void VisitClassScopeFunctionSpecializationDecl(
271        const ClassScopeFunctionSpecializationDecl *D);
272    void VisitVarTemplateDecl(const VarTemplateDecl *D);
273    void VisitVarTemplateSpecializationDecl(
274        const VarTemplateSpecializationDecl *D);
275    void VisitVarTemplatePartialSpecializationDecl(
276        const VarTemplatePartialSpecializationDecl *D);
277    void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D);
278    void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D);
279    void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D);
280    void VisitUsingDecl(const UsingDecl *D);
281    void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D);
282    void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D);
283    void VisitUsingShadowDecl(const UsingShadowDecl *D);
284    void VisitLinkageSpecDecl(const LinkageSpecDecl *D);
285    void VisitAccessSpecDecl(const AccessSpecDecl *D);
286    void VisitFriendDecl(const FriendDecl *D);
287
288    // ObjC Decls
289    void VisitObjCIvarDecl(const ObjCIvarDecl *D);
290    void VisitObjCMethodDecl(const ObjCMethodDecl *D);
291    void VisitObjCCategoryDecl(const ObjCCategoryDecl *D);
292    void VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D);
293    void VisitObjCProtocolDecl(const ObjCProtocolDecl *D);
294    void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D);
295    void VisitObjCImplementationDecl(const ObjCImplementationDecl *D);
296    void VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D);
297    void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
298    void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
299    void VisitBlockDecl(const BlockDecl *D);
300
301    // Stmts.
302    void VisitStmt(const Stmt *Node);
303    void VisitDeclStmt(const DeclStmt *Node);
304    void VisitAttributedStmt(const AttributedStmt *Node);
305    void VisitLabelStmt(const LabelStmt *Node);
306    void VisitGotoStmt(const GotoStmt *Node);
307    void VisitCXXCatchStmt(const CXXCatchStmt *Node);
308
309    // Exprs
310    void VisitExpr(const Expr *Node);
311    void VisitCastExpr(const CastExpr *Node);
312    void VisitDeclRefExpr(const DeclRefExpr *Node);
313    void VisitPredefinedExpr(const PredefinedExpr *Node);
314    void VisitCharacterLiteral(const CharacterLiteral *Node);
315    void VisitIntegerLiteral(const IntegerLiteral *Node);
316    void VisitFloatingLiteral(const FloatingLiteral *Node);
317    void VisitStringLiteral(const StringLiteral *Str);
318    void VisitInitListExpr(const InitListExpr *ILE);
319    void VisitUnaryOperator(const UnaryOperator *Node);
320    void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *Node);
321    void VisitMemberExpr(const MemberExpr *Node);
322    void VisitExtVectorElementExpr(const ExtVectorElementExpr *Node);
323    void VisitBinaryOperator(const BinaryOperator *Node);
324    void VisitCompoundAssignOperator(const CompoundAssignOperator *Node);
325    void VisitAddrLabelExpr(const AddrLabelExpr *Node);
326    void VisitBlockExpr(const BlockExpr *Node);
327    void VisitOpaqueValueExpr(const OpaqueValueExpr *Node);
328
329    // C++
330    void VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node);
331    void VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node);
332    void VisitCXXThisExpr(const CXXThisExpr *Node);
333    void VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node);
334    void VisitCXXConstructExpr(const CXXConstructExpr *Node);
335    void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node);
336    void VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node);
337    void VisitExprWithCleanups(const ExprWithCleanups *Node);
338    void VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node);
339    void dumpCXXTemporary(const CXXTemporary *Temporary);
340    void VisitLambdaExpr(const LambdaExpr *Node) {
341      VisitExpr(Node);
342      dumpDecl(Node->getLambdaClass());
343    }
344
345    // ObjC
346    void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node);
347    void VisitObjCEncodeExpr(const ObjCEncodeExpr *Node);
348    void VisitObjCMessageExpr(const ObjCMessageExpr *Node);
349    void VisitObjCBoxedExpr(const ObjCBoxedExpr *Node);
350    void VisitObjCSelectorExpr(const ObjCSelectorExpr *Node);
351    void VisitObjCProtocolExpr(const ObjCProtocolExpr *Node);
352    void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node);
353    void VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node);
354    void VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node);
355    void VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node);
356
357    // Comments.
358    const char *getCommandName(unsigned CommandID);
359    void dumpComment(const Comment *C);
360
361    // Inline comments.
362    void visitTextComment(const TextComment *C);
363    void visitInlineCommandComment(const InlineCommandComment *C);
364    void visitHTMLStartTagComment(const HTMLStartTagComment *C);
365    void visitHTMLEndTagComment(const HTMLEndTagComment *C);
366
367    // Block comments.
368    void visitBlockCommandComment(const BlockCommandComment *C);
369    void visitParamCommandComment(const ParamCommandComment *C);
370    void visitTParamCommandComment(const TParamCommandComment *C);
371    void visitVerbatimBlockComment(const VerbatimBlockComment *C);
372    void visitVerbatimBlockLineComment(const VerbatimBlockLineComment *C);
373    void visitVerbatimLineComment(const VerbatimLineComment *C);
374  };
375}
376
377//===----------------------------------------------------------------------===//
378//  Utilities
379//===----------------------------------------------------------------------===//
380
381// Print out the appropriate tree structure using the Indents vector.
382// Example of tree and the Indents vector at each level.
383// A        { }
384// |-B      { IT_Child }
385// | `-C    { IT_Child,     IT_LastChild }
386// `-D      { IT_LastChild }
387//   |-E    { IT_LastChild, IT_Child }
388//   `-F    { IT_LastChild, IT_LastChild }
389// Type            non-last element, last element
390// IT_Child        "| "              "|-"
391// IT_LastChild    "  "              "`-"
392void ASTDumper::indent() {
393  if (IsFirstLine)
394    IsFirstLine = false;
395  else
396    OS << "\n";
397
398  ColorScope Color(*this, IndentColor);
399  for (SmallVectorImpl<IndentType>::const_iterator I = Indents.begin(),
400                                                   E = Indents.end();
401       I != E; ++I) {
402    switch (*I) {
403    case IT_Child:
404      if (I == E - 1)
405        OS << "|-";
406      else
407        OS << "| ";
408      continue;
409    case IT_LastChild:
410      if (I == E - 1)
411        OS << "`-";
412      else
413        OS << "  ";
414      continue;
415    }
416    llvm_unreachable("Invalid IndentType");
417  }
418  Indents.push_back(IT_Child);
419}
420
421void ASTDumper::unindent() {
422  Indents.pop_back();
423}
424
425// Call before each potential last child node is to be dumped.  If MoreChildren
426// is false, then this is the last child, otherwise treat as a regular node.
427void ASTDumper::lastChild() {
428  if (!hasMoreChildren())
429    Indents.back() = IT_LastChild;
430}
431
432// MoreChildren should be set before calling another function that may print
433// additional nodes to prevent conflicting final child nodes.
434bool ASTDumper::hasMoreChildren() {
435  return MoreChildren;
436}
437
438void ASTDumper::setMoreChildren(bool Value) {
439  MoreChildren = Value;
440}
441
442void ASTDumper::dumpPointer(const void *Ptr) {
443  ColorScope Color(*this, AddressColor);
444  OS << ' ' << Ptr;
445}
446
447void ASTDumper::dumpLocation(SourceLocation Loc) {
448  if (!SM)
449    return;
450
451  ColorScope Color(*this, LocationColor);
452  SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
453
454  // The general format we print out is filename:line:col, but we drop pieces
455  // that haven't changed since the last loc printed.
456  PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
457
458  if (PLoc.isInvalid()) {
459    OS << "<invalid sloc>";
460    return;
461  }
462
463  if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
464    OS << PLoc.getFilename() << ':' << PLoc.getLine()
465       << ':' << PLoc.getColumn();
466    LastLocFilename = PLoc.getFilename();
467    LastLocLine = PLoc.getLine();
468  } else if (PLoc.getLine() != LastLocLine) {
469    OS << "line" << ':' << PLoc.getLine()
470       << ':' << PLoc.getColumn();
471    LastLocLine = PLoc.getLine();
472  } else {
473    OS << "col" << ':' << PLoc.getColumn();
474  }
475}
476
477void ASTDumper::dumpSourceRange(SourceRange R) {
478  // Can't translate locations if a SourceManager isn't available.
479  if (!SM)
480    return;
481
482  OS << " <";
483  dumpLocation(R.getBegin());
484  if (R.getBegin() != R.getEnd()) {
485    OS << ", ";
486    dumpLocation(R.getEnd());
487  }
488  OS << ">";
489
490  // <t2.c:123:421[blah], t2.c:412:321>
491
492}
493
494void ASTDumper::dumpBareType(QualType T) {
495  ColorScope Color(*this, TypeColor);
496
497  SplitQualType T_split = T.split();
498  OS << "'" << QualType::getAsString(T_split) << "'";
499
500  if (!T.isNull()) {
501    // If the type is sugared, also dump a (shallow) desugared type.
502    SplitQualType D_split = T.getSplitDesugaredType();
503    if (T_split != D_split)
504      OS << ":'" << QualType::getAsString(D_split) << "'";
505  }
506}
507
508void ASTDumper::dumpType(QualType T) {
509  OS << ' ';
510  dumpBareType(T);
511}
512
513void ASTDumper::dumpBareDeclRef(const Decl *D) {
514  {
515    ColorScope Color(*this, DeclKindNameColor);
516    OS << D->getDeclKindName();
517  }
518  dumpPointer(D);
519
520  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
521    ColorScope Color(*this, DeclNameColor);
522    OS << " '" << ND->getDeclName() << '\'';
523  }
524
525  if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
526    dumpType(VD->getType());
527}
528
529void ASTDumper::dumpDeclRef(const Decl *D, const char *Label) {
530  if (!D)
531    return;
532
533  IndentScope Indent(*this);
534  if (Label)
535    OS << Label << ' ';
536  dumpBareDeclRef(D);
537}
538
539void ASTDumper::dumpName(const NamedDecl *ND) {
540  if (ND->getDeclName()) {
541    ColorScope Color(*this, DeclNameColor);
542    OS << ' ' << ND->getNameAsString();
543  }
544}
545
546bool ASTDumper::hasNodes(const DeclContext *DC) {
547  if (!DC)
548    return false;
549
550  return DC->hasExternalLexicalStorage() ||
551         DC->noload_decls_begin() != DC->noload_decls_end();
552}
553
554void ASTDumper::dumpDeclContext(const DeclContext *DC) {
555  if (!DC)
556    return;
557
558  ChildDumper Children(*this);
559  for (auto *D : DC->noload_decls())
560    Children.dump(D);
561
562  if (DC->hasExternalLexicalStorage()) {
563    Children.release();
564
565    lastChild();
566    IndentScope Indent(*this);
567    ColorScope Color(*this, UndeserializedColor);
568    OS << "<undeserialized declarations>";
569  }
570}
571
572void ASTDumper::dumpLookups(const DeclContext *DC) {
573  IndentScope Indent(*this);
574
575  OS << "StoredDeclsMap ";
576  dumpBareDeclRef(cast<Decl>(DC));
577
578  const DeclContext *Primary = DC->getPrimaryContext();
579  if (Primary != DC) {
580    OS << " primary";
581    dumpPointer(cast<Decl>(Primary));
582  }
583
584  bool HasUndeserializedLookups = Primary->hasExternalVisibleStorage();
585
586  DeclContext::all_lookups_iterator I = Primary->noload_lookups_begin(),
587                                    E = Primary->noload_lookups_end();
588  while (I != E) {
589    DeclarationName Name = I.getLookupName();
590    DeclContextLookupResult R = *I++;
591    if (I == E && !HasUndeserializedLookups)
592      lastChild();
593
594    IndentScope Indent(*this);
595    OS << "DeclarationName ";
596    {
597      ColorScope Color(*this, DeclNameColor);
598      OS << '\'' << Name << '\'';
599    }
600
601    for (DeclContextLookupResult::iterator RI = R.begin(), RE = R.end();
602         RI != RE; ++RI) {
603      if (RI + 1 == RE)
604        lastChild();
605      dumpDeclRef(*RI);
606      if ((*RI)->isHidden())
607        OS << " hidden";
608    }
609  }
610
611  if (HasUndeserializedLookups) {
612    lastChild();
613    IndentScope Indent(*this);
614    ColorScope Color(*this, UndeserializedColor);
615    OS << "<undeserialized lookups>";
616  }
617}
618
619void ASTDumper::dumpAttr(const Attr *A) {
620  IndentScope Indent(*this);
621  {
622    ColorScope Color(*this, AttrColor);
623
624    switch (A->getKind()) {
625#define ATTR(X) case attr::X: OS << #X; break;
626#include "clang/Basic/AttrList.inc"
627    default: llvm_unreachable("unexpected attribute kind");
628    }
629    OS << "Attr";
630  }
631  dumpPointer(A);
632  dumpSourceRange(A->getRange());
633  if (A->isInherited())
634    OS << " Inherited";
635  if (A->isImplicit())
636    OS << " Implicit";
637#include "clang/AST/AttrDump.inc"
638}
639
640static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {}
641
642template<typename T>
643static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) {
644  const T *First = D->getFirstDecl();
645  if (First != D)
646    OS << " first " << First;
647}
648
649template<typename T>
650static void dumpPreviousDeclImpl(raw_ostream &OS, const Redeclarable<T> *D) {
651  const T *Prev = D->getPreviousDecl();
652  if (Prev)
653    OS << " prev " << Prev;
654}
655
656/// Dump the previous declaration in the redeclaration chain for a declaration,
657/// if any.
658static void dumpPreviousDecl(raw_ostream &OS, const Decl *D) {
659  switch (D->getKind()) {
660#define DECL(DERIVED, BASE) \
661  case Decl::DERIVED: \
662    return dumpPreviousDeclImpl(OS, cast<DERIVED##Decl>(D));
663#define ABSTRACT_DECL(DECL)
664#include "clang/AST/DeclNodes.inc"
665  }
666  llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
667}
668
669//===----------------------------------------------------------------------===//
670//  C++ Utilities
671//===----------------------------------------------------------------------===//
672
673void ASTDumper::dumpAccessSpecifier(AccessSpecifier AS) {
674  switch (AS) {
675  case AS_none:
676    break;
677  case AS_public:
678    OS << "public";
679    break;
680  case AS_protected:
681    OS << "protected";
682    break;
683  case AS_private:
684    OS << "private";
685    break;
686  }
687}
688
689void ASTDumper::dumpCXXCtorInitializer(const CXXCtorInitializer *Init) {
690  IndentScope Indent(*this);
691  OS << "CXXCtorInitializer";
692  if (Init->isAnyMemberInitializer()) {
693    OS << ' ';
694    dumpBareDeclRef(Init->getAnyMember());
695  } else {
696    dumpType(QualType(Init->getBaseClass(), 0));
697  }
698  dumpStmt(Init->getInit());
699}
700
701void ASTDumper::dumpTemplateParameters(const TemplateParameterList *TPL) {
702  if (!TPL)
703    return;
704
705  for (TemplateParameterList::const_iterator I = TPL->begin(), E = TPL->end();
706       I != E; ++I)
707    dumpDecl(*I);
708}
709
710void ASTDumper::dumpTemplateArgumentListInfo(
711    const TemplateArgumentListInfo &TALI) {
712  for (unsigned i = 0, e = TALI.size(); i < e; ++i) {
713    if (i + 1 == e)
714      lastChild();
715    dumpTemplateArgumentLoc(TALI[i]);
716  }
717}
718
719void ASTDumper::dumpTemplateArgumentLoc(const TemplateArgumentLoc &A) {
720  dumpTemplateArgument(A.getArgument(), A.getSourceRange());
721}
722
723void ASTDumper::dumpTemplateArgumentList(const TemplateArgumentList &TAL) {
724  for (unsigned i = 0, e = TAL.size(); i < e; ++i)
725    dumpTemplateArgument(TAL[i]);
726}
727
728void ASTDumper::dumpTemplateArgument(const TemplateArgument &A, SourceRange R) {
729  IndentScope Indent(*this);
730  OS << "TemplateArgument";
731  if (R.isValid())
732    dumpSourceRange(R);
733
734  switch (A.getKind()) {
735  case TemplateArgument::Null:
736    OS << " null";
737    break;
738  case TemplateArgument::Type:
739    OS << " type";
740    lastChild();
741    dumpType(A.getAsType());
742    break;
743  case TemplateArgument::Declaration:
744    OS << " decl";
745    lastChild();
746    dumpDeclRef(A.getAsDecl());
747    break;
748  case TemplateArgument::NullPtr:
749    OS << " nullptr";
750    break;
751  case TemplateArgument::Integral:
752    OS << " integral " << A.getAsIntegral();
753    break;
754  case TemplateArgument::Template:
755    OS << " template ";
756    A.getAsTemplate().dump(OS);
757    break;
758  case TemplateArgument::TemplateExpansion:
759    OS << " template expansion";
760    A.getAsTemplateOrTemplatePattern().dump(OS);
761    break;
762  case TemplateArgument::Expression:
763    OS << " expr";
764    lastChild();
765    dumpStmt(A.getAsExpr());
766    break;
767  case TemplateArgument::Pack:
768    OS << " pack";
769    for (TemplateArgument::pack_iterator I = A.pack_begin(), E = A.pack_end();
770         I != E; ++I) {
771      if (I + 1 == E)
772        lastChild();
773      dumpTemplateArgument(*I);
774    }
775    break;
776  }
777}
778
779//===----------------------------------------------------------------------===//
780//  Decl dumping methods.
781//===----------------------------------------------------------------------===//
782
783void ASTDumper::dumpDecl(const Decl *D) {
784  IndentScope Indent(*this);
785
786  if (!D) {
787    ColorScope Color(*this, NullColor);
788    OS << "<<<NULL>>>";
789    return;
790  }
791
792  {
793    ColorScope Color(*this, DeclKindNameColor);
794    OS << D->getDeclKindName() << "Decl";
795  }
796  dumpPointer(D);
797  if (D->getLexicalDeclContext() != D->getDeclContext())
798    OS << " parent " << cast<Decl>(D->getDeclContext());
799  dumpPreviousDecl(OS, D);
800  dumpSourceRange(D->getSourceRange());
801  OS << ' ';
802  dumpLocation(D->getLocation());
803  if (Module *M = D->getOwningModule())
804    OS << " in " << M->getFullModuleName();
805  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
806    if (ND->isHidden())
807      OS << " hidden";
808  if (D->isImplicit())
809    OS << " implicit";
810  if (D->isUsed())
811    OS << " used";
812  else if (D->isReferenced())
813    OS << " referenced";
814  if (D->isInvalidDecl())
815    OS << " invalid";
816
817  bool HasAttrs = D->hasAttrs();
818  const FullComment *Comment =
819      D->getASTContext().getLocalCommentForDeclUncached(D);
820  // Decls within functions are visited by the body
821  bool HasDeclContext = !isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D) &&
822                         hasNodes(dyn_cast<DeclContext>(D));
823
824  setMoreChildren(HasAttrs || Comment || HasDeclContext);
825  ConstDeclVisitor<ASTDumper>::Visit(D);
826
827  setMoreChildren(Comment || HasDeclContext);
828  for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end();
829       I != E; ++I) {
830    if (I + 1 == E)
831      lastChild();
832    dumpAttr(*I);
833  }
834
835  setMoreChildren(HasDeclContext);
836  lastChild();
837  dumpFullComment(Comment);
838
839  setMoreChildren(false);
840  if (HasDeclContext)
841    dumpDeclContext(cast<DeclContext>(D));
842}
843
844void ASTDumper::VisitLabelDecl(const LabelDecl *D) {
845  dumpName(D);
846}
847
848void ASTDumper::VisitTypedefDecl(const TypedefDecl *D) {
849  dumpName(D);
850  dumpType(D->getUnderlyingType());
851  if (D->isModulePrivate())
852    OS << " __module_private__";
853}
854
855void ASTDumper::VisitEnumDecl(const EnumDecl *D) {
856  if (D->isScoped()) {
857    if (D->isScopedUsingClassTag())
858      OS << " class";
859    else
860      OS << " struct";
861  }
862  dumpName(D);
863  if (D->isModulePrivate())
864    OS << " __module_private__";
865  if (D->isFixed())
866    dumpType(D->getIntegerType());
867}
868
869void ASTDumper::VisitRecordDecl(const RecordDecl *D) {
870  OS << ' ' << D->getKindName();
871  dumpName(D);
872  if (D->isModulePrivate())
873    OS << " __module_private__";
874  if (D->isCompleteDefinition())
875    OS << " definition";
876}
877
878void ASTDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
879  dumpName(D);
880  dumpType(D->getType());
881  if (const Expr *Init = D->getInitExpr()) {
882    lastChild();
883    dumpStmt(Init);
884  }
885}
886
887void ASTDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
888  dumpName(D);
889  dumpType(D->getType());
890
891  ChildDumper Children(*this);
892  for (auto *Child : D->chain())
893    Children.dumpRef(Child);
894}
895
896void ASTDumper::VisitFunctionDecl(const FunctionDecl *D) {
897  dumpName(D);
898  dumpType(D->getType());
899
900  StorageClass SC = D->getStorageClass();
901  if (SC != SC_None)
902    OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
903  if (D->isInlineSpecified())
904    OS << " inline";
905  if (D->isVirtualAsWritten())
906    OS << " virtual";
907  if (D->isModulePrivate())
908    OS << " __module_private__";
909
910  if (D->isPure())
911    OS << " pure";
912  else if (D->isDeletedAsWritten())
913    OS << " delete";
914
915  if (const FunctionProtoType *FPT = D->getType()->getAs<FunctionProtoType>()) {
916    FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
917    switch (EPI.ExceptionSpecType) {
918    default: break;
919    case EST_Unevaluated:
920      OS << " noexcept-unevaluated " << EPI.ExceptionSpecDecl;
921      break;
922    case EST_Uninstantiated:
923      OS << " noexcept-uninstantiated " << EPI.ExceptionSpecTemplate;
924      break;
925    }
926  }
927
928  bool OldMoreChildren = hasMoreChildren();
929  const FunctionTemplateSpecializationInfo *FTSI =
930      D->getTemplateSpecializationInfo();
931  bool HasTemplateSpecialization = FTSI;
932
933  bool HasNamedDecls = D->getDeclsInPrototypeScope().begin() !=
934                       D->getDeclsInPrototypeScope().end();
935
936  bool HasFunctionDecls = D->param_begin() != D->param_end();
937
938  const CXXConstructorDecl *C = dyn_cast<CXXConstructorDecl>(D);
939  bool HasCtorInitializers = C && C->init_begin() != C->init_end();
940
941  bool HasDeclarationBody = D->doesThisDeclarationHaveABody();
942
943  setMoreChildren(OldMoreChildren || HasNamedDecls || HasFunctionDecls ||
944                  HasCtorInitializers || HasDeclarationBody);
945  if (HasTemplateSpecialization) {
946    lastChild();
947    dumpTemplateArgumentList(*FTSI->TemplateArguments);
948  }
949
950  setMoreChildren(OldMoreChildren || HasFunctionDecls ||
951                  HasCtorInitializers || HasDeclarationBody);
952  for (ArrayRef<NamedDecl *>::iterator
953       I = D->getDeclsInPrototypeScope().begin(),
954       E = D->getDeclsInPrototypeScope().end(); I != E; ++I) {
955    if (I + 1 == E)
956      lastChild();
957    dumpDecl(*I);
958  }
959
960  setMoreChildren(OldMoreChildren || HasCtorInitializers || HasDeclarationBody);
961  for (FunctionDecl::param_const_iterator I = D->param_begin(),
962                                          E = D->param_end();
963       I != E; ++I) {
964    if (I + 1 == E)
965      lastChild();
966    dumpDecl(*I);
967  }
968
969  setMoreChildren(OldMoreChildren || HasDeclarationBody);
970  if (HasCtorInitializers)
971    for (CXXConstructorDecl::init_const_iterator I = C->init_begin(),
972                                                 E = C->init_end();
973         I != E; ++I) {
974      if (I + 1 == E)
975        lastChild();
976      dumpCXXCtorInitializer(*I);
977  }
978
979  setMoreChildren(OldMoreChildren);
980  if (HasDeclarationBody) {
981    lastChild();
982    dumpStmt(D->getBody());
983  }
984}
985
986void ASTDumper::VisitFieldDecl(const FieldDecl *D) {
987  dumpName(D);
988  dumpType(D->getType());
989  if (D->isMutable())
990    OS << " mutable";
991  if (D->isModulePrivate())
992    OS << " __module_private__";
993
994  bool OldMoreChildren = hasMoreChildren();
995  bool IsBitField = D->isBitField();
996  Expr *Init = D->getInClassInitializer();
997  bool HasInit = Init;
998
999  setMoreChildren(OldMoreChildren || HasInit);
1000  if (IsBitField) {
1001    lastChild();
1002    dumpStmt(D->getBitWidth());
1003  }
1004  setMoreChildren(OldMoreChildren);
1005  if (HasInit) {
1006    lastChild();
1007    dumpStmt(Init);
1008  }
1009}
1010
1011void ASTDumper::VisitVarDecl(const VarDecl *D) {
1012  dumpName(D);
1013  dumpType(D->getType());
1014  StorageClass SC = D->getStorageClass();
1015  if (SC != SC_None)
1016    OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
1017  switch (D->getTLSKind()) {
1018  case VarDecl::TLS_None: break;
1019  case VarDecl::TLS_Static: OS << " tls"; break;
1020  case VarDecl::TLS_Dynamic: OS << " tls_dynamic"; break;
1021  }
1022  if (D->isModulePrivate())
1023    OS << " __module_private__";
1024  if (D->isNRVOVariable())
1025    OS << " nrvo";
1026  if (D->hasInit()) {
1027    lastChild();
1028    dumpStmt(D->getInit());
1029  }
1030}
1031
1032void ASTDumper::VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) {
1033  lastChild();
1034  dumpStmt(D->getAsmString());
1035}
1036
1037void ASTDumper::VisitImportDecl(const ImportDecl *D) {
1038  OS << ' ' << D->getImportedModule()->getFullModuleName();
1039}
1040
1041//===----------------------------------------------------------------------===//
1042// C++ Declarations
1043//===----------------------------------------------------------------------===//
1044
1045void ASTDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
1046  dumpName(D);
1047  if (D->isInline())
1048    OS << " inline";
1049  if (!D->isOriginalNamespace())
1050    dumpDeclRef(D->getOriginalNamespace(), "original");
1051}
1052
1053void ASTDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
1054  OS << ' ';
1055  dumpBareDeclRef(D->getNominatedNamespace());
1056}
1057
1058void ASTDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
1059  dumpName(D);
1060  dumpDeclRef(D->getAliasedNamespace());
1061}
1062
1063void ASTDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
1064  dumpName(D);
1065  dumpType(D->getUnderlyingType());
1066}
1067
1068void ASTDumper::VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) {
1069  dumpName(D);
1070  dumpTemplateParameters(D->getTemplateParameters());
1071  dumpDecl(D->getTemplatedDecl());
1072}
1073
1074void ASTDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
1075  VisitRecordDecl(D);
1076  if (!D->isCompleteDefinition())
1077    return;
1078
1079  for (const auto &I : D->bases()) {
1080    IndentScope Indent(*this);
1081    if (I.isVirtual())
1082      OS << "virtual ";
1083    dumpAccessSpecifier(I.getAccessSpecifier());
1084    dumpType(I.getType());
1085    if (I.isPackExpansion())
1086      OS << "...";
1087  }
1088}
1089
1090void ASTDumper::VisitStaticAssertDecl(const StaticAssertDecl *D) {
1091  dumpStmt(D->getAssertExpr());
1092  lastChild();
1093  dumpStmt(D->getMessage());
1094}
1095
1096template<typename SpecializationDecl>
1097void ASTDumper::VisitTemplateDeclSpecialization(ChildDumper &Children,
1098                                                const SpecializationDecl *D,
1099                                                bool DumpExplicitInst,
1100                                                bool DumpRefOnly) {
1101  bool DumpedAny = false;
1102  for (auto *RedeclWithBadType : D->redecls()) {
1103    // FIXME: The redecls() range sometimes has elements of a less-specific
1104    // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives
1105    // us TagDecls, and should give CXXRecordDecls).
1106    auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType);
1107    if (!Redecl) {
1108      // Found the injected-class-name for a class template. This will be dumped
1109      // as part of its surrounding class so we don't need to dump it here.
1110      assert(isa<CXXRecordDecl>(RedeclWithBadType) &&
1111             "expected an injected-class-name");
1112      continue;
1113    }
1114
1115    switch (Redecl->getTemplateSpecializationKind()) {
1116    case TSK_ExplicitInstantiationDeclaration:
1117    case TSK_ExplicitInstantiationDefinition:
1118      if (!DumpExplicitInst)
1119        break;
1120      // Fall through.
1121    case TSK_Undeclared:
1122    case TSK_ImplicitInstantiation:
1123      Children.dump(Redecl, DumpRefOnly);
1124      DumpedAny = true;
1125      break;
1126    case TSK_ExplicitSpecialization:
1127      break;
1128    }
1129  }
1130
1131  // Ensure we dump at least one decl for each specialization.
1132  if (!DumpedAny)
1133    Children.dumpRef(D);
1134}
1135
1136template<typename TemplateDecl>
1137void ASTDumper::VisitTemplateDecl(const TemplateDecl *D,
1138                                  bool DumpExplicitInst) {
1139  dumpName(D);
1140  dumpTemplateParameters(D->getTemplateParameters());
1141
1142  ChildDumper Children(*this);
1143  Children.dump(D->getTemplatedDecl());
1144
1145  for (auto *Child : D->specializations())
1146    VisitTemplateDeclSpecialization(Children, Child, DumpExplicitInst,
1147                                    !D->isCanonicalDecl());
1148}
1149
1150void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
1151  // FIXME: We don't add a declaration of a function template specialization
1152  // to its context when it's explicitly instantiated, so dump explicit
1153  // instantiations when we dump the template itself.
1154  VisitTemplateDecl(D, true);
1155}
1156
1157void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
1158  VisitTemplateDecl(D, false);
1159}
1160
1161void ASTDumper::VisitClassTemplateSpecializationDecl(
1162    const ClassTemplateSpecializationDecl *D) {
1163  VisitCXXRecordDecl(D);
1164  dumpTemplateArgumentList(D->getTemplateArgs());
1165}
1166
1167void ASTDumper::VisitClassTemplatePartialSpecializationDecl(
1168    const ClassTemplatePartialSpecializationDecl *D) {
1169  VisitClassTemplateSpecializationDecl(D);
1170  dumpTemplateParameters(D->getTemplateParameters());
1171}
1172
1173void ASTDumper::VisitClassScopeFunctionSpecializationDecl(
1174    const ClassScopeFunctionSpecializationDecl *D) {
1175  dumpDeclRef(D->getSpecialization());
1176  if (D->hasExplicitTemplateArgs())
1177    dumpTemplateArgumentListInfo(D->templateArgs());
1178}
1179
1180void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
1181  VisitTemplateDecl(D, false);
1182}
1183
1184void ASTDumper::VisitVarTemplateSpecializationDecl(
1185    const VarTemplateSpecializationDecl *D) {
1186  dumpTemplateArgumentList(D->getTemplateArgs());
1187  VisitVarDecl(D);
1188}
1189
1190void ASTDumper::VisitVarTemplatePartialSpecializationDecl(
1191    const VarTemplatePartialSpecializationDecl *D) {
1192  dumpTemplateParameters(D->getTemplateParameters());
1193  VisitVarTemplateSpecializationDecl(D);
1194}
1195
1196void ASTDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
1197  if (D->wasDeclaredWithTypename())
1198    OS << " typename";
1199  else
1200    OS << " class";
1201  if (D->isParameterPack())
1202    OS << " ...";
1203  dumpName(D);
1204  if (D->hasDefaultArgument()) {
1205    lastChild();
1206    dumpTemplateArgument(D->getDefaultArgument());
1207  }
1208}
1209
1210void ASTDumper::VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
1211  dumpType(D->getType());
1212  if (D->isParameterPack())
1213    OS << " ...";
1214  dumpName(D);
1215  if (D->hasDefaultArgument()) {
1216    lastChild();
1217    dumpTemplateArgument(D->getDefaultArgument());
1218  }
1219}
1220
1221void ASTDumper::VisitTemplateTemplateParmDecl(
1222    const TemplateTemplateParmDecl *D) {
1223  if (D->isParameterPack())
1224    OS << " ...";
1225  dumpName(D);
1226  dumpTemplateParameters(D->getTemplateParameters());
1227  if (D->hasDefaultArgument()) {
1228    lastChild();
1229    dumpTemplateArgumentLoc(D->getDefaultArgument());
1230  }
1231}
1232
1233void ASTDumper::VisitUsingDecl(const UsingDecl *D) {
1234  OS << ' ';
1235  D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1236  OS << D->getNameAsString();
1237}
1238
1239void ASTDumper::VisitUnresolvedUsingTypenameDecl(
1240    const UnresolvedUsingTypenameDecl *D) {
1241  OS << ' ';
1242  D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1243  OS << D->getNameAsString();
1244}
1245
1246void ASTDumper::VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
1247  OS << ' ';
1248  D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
1249  OS << D->getNameAsString();
1250  dumpType(D->getType());
1251}
1252
1253void ASTDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
1254  OS << ' ';
1255  dumpBareDeclRef(D->getTargetDecl());
1256}
1257
1258void ASTDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
1259  switch (D->getLanguage()) {
1260  case LinkageSpecDecl::lang_c: OS << " C"; break;
1261  case LinkageSpecDecl::lang_cxx: OS << " C++"; break;
1262  }
1263}
1264
1265void ASTDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
1266  OS << ' ';
1267  dumpAccessSpecifier(D->getAccess());
1268}
1269
1270void ASTDumper::VisitFriendDecl(const FriendDecl *D) {
1271  lastChild();
1272  if (TypeSourceInfo *T = D->getFriendType())
1273    dumpType(T->getType());
1274  else
1275    dumpDecl(D->getFriendDecl());
1276}
1277
1278//===----------------------------------------------------------------------===//
1279// Obj-C Declarations
1280//===----------------------------------------------------------------------===//
1281
1282void ASTDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
1283  dumpName(D);
1284  dumpType(D->getType());
1285  if (D->getSynthesize())
1286    OS << " synthesize";
1287
1288  switch (D->getAccessControl()) {
1289  case ObjCIvarDecl::None:
1290    OS << " none";
1291    break;
1292  case ObjCIvarDecl::Private:
1293    OS << " private";
1294    break;
1295  case ObjCIvarDecl::Protected:
1296    OS << " protected";
1297    break;
1298  case ObjCIvarDecl::Public:
1299    OS << " public";
1300    break;
1301  case ObjCIvarDecl::Package:
1302    OS << " package";
1303    break;
1304  }
1305}
1306
1307void ASTDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
1308  if (D->isInstanceMethod())
1309    OS << " -";
1310  else
1311    OS << " +";
1312  dumpName(D);
1313  dumpType(D->getReturnType());
1314
1315  bool OldMoreChildren = hasMoreChildren();
1316  bool IsVariadic = D->isVariadic();
1317  bool HasBody = D->hasBody();
1318
1319  setMoreChildren(OldMoreChildren || IsVariadic || HasBody);
1320  if (D->isThisDeclarationADefinition()) {
1321    lastChild();
1322    dumpDeclContext(D);
1323  } else {
1324    for (ObjCMethodDecl::param_const_iterator I = D->param_begin(),
1325                                              E = D->param_end();
1326         I != E; ++I) {
1327      if (I + 1 == E)
1328        lastChild();
1329      dumpDecl(*I);
1330    }
1331  }
1332
1333  setMoreChildren(OldMoreChildren || HasBody);
1334  if (IsVariadic) {
1335    lastChild();
1336    IndentScope Indent(*this);
1337    OS << "...";
1338  }
1339
1340  setMoreChildren(OldMoreChildren);
1341  if (HasBody) {
1342    lastChild();
1343    dumpStmt(D->getBody());
1344  }
1345}
1346
1347void ASTDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
1348  dumpName(D);
1349  dumpDeclRef(D->getClassInterface());
1350  if (D->protocol_begin() == D->protocol_end())
1351    lastChild();
1352  dumpDeclRef(D->getImplementation());
1353  for (ObjCCategoryDecl::protocol_iterator I = D->protocol_begin(),
1354                                           E = D->protocol_end();
1355       I != E; ++I) {
1356    if (I + 1 == E)
1357      lastChild();
1358    dumpDeclRef(*I);
1359  }
1360}
1361
1362void ASTDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
1363  dumpName(D);
1364  dumpDeclRef(D->getClassInterface());
1365  lastChild();
1366  dumpDeclRef(D->getCategoryDecl());
1367}
1368
1369void ASTDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
1370  dumpName(D);
1371
1372  ChildDumper Children(*this);
1373  for (auto *Child : D->protocols())
1374    Children.dumpRef(Child);
1375}
1376
1377void ASTDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
1378  dumpName(D);
1379  dumpDeclRef(D->getSuperClass(), "super");
1380
1381  ChildDumper Children(*this);
1382  Children.dumpRef(D->getImplementation());
1383  for (auto *Child : D->protocols())
1384    Children.dumpRef(Child);
1385}
1386
1387void ASTDumper::VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
1388  dumpName(D);
1389  dumpDeclRef(D->getSuperClass(), "super");
1390  if (D->init_begin() == D->init_end())
1391    lastChild();
1392  dumpDeclRef(D->getClassInterface());
1393  for (ObjCImplementationDecl::init_const_iterator I = D->init_begin(),
1394                                                   E = D->init_end();
1395       I != E; ++I) {
1396    if (I + 1 == E)
1397      lastChild();
1398    dumpCXXCtorInitializer(*I);
1399  }
1400}
1401
1402void ASTDumper::VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *D) {
1403  dumpName(D);
1404  lastChild();
1405  dumpDeclRef(D->getClassInterface());
1406}
1407
1408void ASTDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
1409  dumpName(D);
1410  dumpType(D->getType());
1411
1412  if (D->getPropertyImplementation() == ObjCPropertyDecl::Required)
1413    OS << " required";
1414  else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
1415    OS << " optional";
1416
1417  ObjCPropertyDecl::PropertyAttributeKind Attrs = D->getPropertyAttributes();
1418  if (Attrs != ObjCPropertyDecl::OBJC_PR_noattr) {
1419    if (Attrs & ObjCPropertyDecl::OBJC_PR_readonly)
1420      OS << " readonly";
1421    if (Attrs & ObjCPropertyDecl::OBJC_PR_assign)
1422      OS << " assign";
1423    if (Attrs & ObjCPropertyDecl::OBJC_PR_readwrite)
1424      OS << " readwrite";
1425    if (Attrs & ObjCPropertyDecl::OBJC_PR_retain)
1426      OS << " retain";
1427    if (Attrs & ObjCPropertyDecl::OBJC_PR_copy)
1428      OS << " copy";
1429    if (Attrs & ObjCPropertyDecl::OBJC_PR_nonatomic)
1430      OS << " nonatomic";
1431    if (Attrs & ObjCPropertyDecl::OBJC_PR_atomic)
1432      OS << " atomic";
1433    if (Attrs & ObjCPropertyDecl::OBJC_PR_weak)
1434      OS << " weak";
1435    if (Attrs & ObjCPropertyDecl::OBJC_PR_strong)
1436      OS << " strong";
1437    if (Attrs & ObjCPropertyDecl::OBJC_PR_unsafe_unretained)
1438      OS << " unsafe_unretained";
1439    if (Attrs & ObjCPropertyDecl::OBJC_PR_getter) {
1440      if (!(Attrs & ObjCPropertyDecl::OBJC_PR_setter))
1441        lastChild();
1442      dumpDeclRef(D->getGetterMethodDecl(), "getter");
1443    }
1444    if (Attrs & ObjCPropertyDecl::OBJC_PR_setter) {
1445      lastChild();
1446      dumpDeclRef(D->getSetterMethodDecl(), "setter");
1447    }
1448  }
1449}
1450
1451void ASTDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
1452  dumpName(D->getPropertyDecl());
1453  if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
1454    OS << " synthesize";
1455  else
1456    OS << " dynamic";
1457  dumpDeclRef(D->getPropertyDecl());
1458  lastChild();
1459  dumpDeclRef(D->getPropertyIvarDecl());
1460}
1461
1462void ASTDumper::VisitBlockDecl(const BlockDecl *D) {
1463  for (auto I : D->params())
1464    dumpDecl(I);
1465
1466  if (D->isVariadic()) {
1467    IndentScope Indent(*this);
1468    OS << "...";
1469  }
1470
1471  if (D->capturesCXXThis()) {
1472    IndentScope Indent(*this);
1473    OS << "capture this";
1474  }
1475  for (const auto &I : D->captures()) {
1476    IndentScope Indent(*this);
1477    OS << "capture";
1478    if (I.isByRef())
1479      OS << " byref";
1480    if (I.isNested())
1481      OS << " nested";
1482    if (I.getVariable()) {
1483      OS << ' ';
1484      dumpBareDeclRef(I.getVariable());
1485    }
1486    if (I.hasCopyExpr())
1487      dumpStmt(I.getCopyExpr());
1488  }
1489  lastChild();
1490  dumpStmt(D->getBody());
1491}
1492
1493//===----------------------------------------------------------------------===//
1494//  Stmt dumping methods.
1495//===----------------------------------------------------------------------===//
1496
1497void ASTDumper::dumpStmt(const Stmt *S) {
1498  IndentScope Indent(*this);
1499
1500  if (!S) {
1501    ColorScope Color(*this, NullColor);
1502    OS << "<<<NULL>>>";
1503    return;
1504  }
1505
1506  if (const DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
1507    VisitDeclStmt(DS);
1508    return;
1509  }
1510
1511  setMoreChildren(!S->children().empty());
1512  ConstStmtVisitor<ASTDumper>::Visit(S);
1513  setMoreChildren(false);
1514  for (Stmt::const_child_range CI = S->children(); CI; ++CI) {
1515    Stmt::const_child_range Next = CI;
1516    ++Next;
1517    if (!Next)
1518      lastChild();
1519    dumpStmt(*CI);
1520  }
1521}
1522
1523void ASTDumper::VisitStmt(const Stmt *Node) {
1524  {
1525    ColorScope Color(*this, StmtColor);
1526    OS << Node->getStmtClassName();
1527  }
1528  dumpPointer(Node);
1529  dumpSourceRange(Node->getSourceRange());
1530}
1531
1532void ASTDumper::VisitDeclStmt(const DeclStmt *Node) {
1533  VisitStmt(Node);
1534  for (DeclStmt::const_decl_iterator I = Node->decl_begin(),
1535                                     E = Node->decl_end();
1536       I != E; ++I) {
1537    if (I + 1 == E)
1538      lastChild();
1539    dumpDecl(*I);
1540  }
1541}
1542
1543void ASTDumper::VisitAttributedStmt(const AttributedStmt *Node) {
1544  VisitStmt(Node);
1545  for (ArrayRef<const Attr *>::iterator I = Node->getAttrs().begin(),
1546                                        E = Node->getAttrs().end();
1547       I != E; ++I) {
1548    if (I + 1 == E)
1549      lastChild();
1550    dumpAttr(*I);
1551  }
1552}
1553
1554void ASTDumper::VisitLabelStmt(const LabelStmt *Node) {
1555  VisitStmt(Node);
1556  OS << " '" << Node->getName() << "'";
1557}
1558
1559void ASTDumper::VisitGotoStmt(const GotoStmt *Node) {
1560  VisitStmt(Node);
1561  OS << " '" << Node->getLabel()->getName() << "'";
1562  dumpPointer(Node->getLabel());
1563}
1564
1565void ASTDumper::VisitCXXCatchStmt(const CXXCatchStmt *Node) {
1566  VisitStmt(Node);
1567  dumpDecl(Node->getExceptionDecl());
1568}
1569
1570//===----------------------------------------------------------------------===//
1571//  Expr dumping methods.
1572//===----------------------------------------------------------------------===//
1573
1574void ASTDumper::VisitExpr(const Expr *Node) {
1575  VisitStmt(Node);
1576  dumpType(Node->getType());
1577
1578  {
1579    ColorScope Color(*this, ValueKindColor);
1580    switch (Node->getValueKind()) {
1581    case VK_RValue:
1582      break;
1583    case VK_LValue:
1584      OS << " lvalue";
1585      break;
1586    case VK_XValue:
1587      OS << " xvalue";
1588      break;
1589    }
1590  }
1591
1592  {
1593    ColorScope Color(*this, ObjectKindColor);
1594    switch (Node->getObjectKind()) {
1595    case OK_Ordinary:
1596      break;
1597    case OK_BitField:
1598      OS << " bitfield";
1599      break;
1600    case OK_ObjCProperty:
1601      OS << " objcproperty";
1602      break;
1603    case OK_ObjCSubscript:
1604      OS << " objcsubscript";
1605      break;
1606    case OK_VectorComponent:
1607      OS << " vectorcomponent";
1608      break;
1609    }
1610  }
1611}
1612
1613static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {
1614  if (Node->path_empty())
1615    return;
1616
1617  OS << " (";
1618  bool First = true;
1619  for (CastExpr::path_const_iterator I = Node->path_begin(),
1620                                     E = Node->path_end();
1621       I != E; ++I) {
1622    const CXXBaseSpecifier *Base = *I;
1623    if (!First)
1624      OS << " -> ";
1625
1626    const CXXRecordDecl *RD =
1627    cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1628
1629    if (Base->isVirtual())
1630      OS << "virtual ";
1631    OS << RD->getName();
1632    First = false;
1633  }
1634
1635  OS << ')';
1636}
1637
1638void ASTDumper::VisitCastExpr(const CastExpr *Node) {
1639  VisitExpr(Node);
1640  OS << " <";
1641  {
1642    ColorScope Color(*this, CastColor);
1643    OS << Node->getCastKindName();
1644  }
1645  dumpBasePath(OS, Node);
1646  OS << ">";
1647}
1648
1649void ASTDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
1650  VisitExpr(Node);
1651
1652  OS << " ";
1653  dumpBareDeclRef(Node->getDecl());
1654  if (Node->getDecl() != Node->getFoundDecl()) {
1655    OS << " (";
1656    dumpBareDeclRef(Node->getFoundDecl());
1657    OS << ")";
1658  }
1659}
1660
1661void ASTDumper::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *Node) {
1662  VisitExpr(Node);
1663  OS << " (";
1664  if (!Node->requiresADL())
1665    OS << "no ";
1666  OS << "ADL) = '" << Node->getName() << '\'';
1667
1668  UnresolvedLookupExpr::decls_iterator
1669    I = Node->decls_begin(), E = Node->decls_end();
1670  if (I == E)
1671    OS << " empty";
1672  for (; I != E; ++I)
1673    dumpPointer(*I);
1674}
1675
1676void ASTDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
1677  VisitExpr(Node);
1678
1679  {
1680    ColorScope Color(*this, DeclKindNameColor);
1681    OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
1682  }
1683  OS << "='" << *Node->getDecl() << "'";
1684  dumpPointer(Node->getDecl());
1685  if (Node->isFreeIvar())
1686    OS << " isFreeIvar";
1687}
1688
1689void ASTDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
1690  VisitExpr(Node);
1691  switch (Node->getIdentType()) {
1692  default: llvm_unreachable("unknown case");
1693  case PredefinedExpr::Func:           OS <<  " __func__"; break;
1694  case PredefinedExpr::Function:       OS <<  " __FUNCTION__"; break;
1695  case PredefinedExpr::FuncDName:      OS <<  " __FUNCDNAME__"; break;
1696  case PredefinedExpr::LFunction:      OS <<  " L__FUNCTION__"; break;
1697  case PredefinedExpr::PrettyFunction: OS <<  " __PRETTY_FUNCTION__";break;
1698  case PredefinedExpr::FuncSig:        OS <<  " __FUNCSIG__"; break;
1699  }
1700}
1701
1702void ASTDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
1703  VisitExpr(Node);
1704  ColorScope Color(*this, ValueColor);
1705  OS << " " << Node->getValue();
1706}
1707
1708void ASTDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {
1709  VisitExpr(Node);
1710
1711  bool isSigned = Node->getType()->isSignedIntegerType();
1712  ColorScope Color(*this, ValueColor);
1713  OS << " " << Node->getValue().toString(10, isSigned);
1714}
1715
1716void ASTDumper::VisitFloatingLiteral(const FloatingLiteral *Node) {
1717  VisitExpr(Node);
1718  ColorScope Color(*this, ValueColor);
1719  OS << " " << Node->getValueAsApproximateDouble();
1720}
1721
1722void ASTDumper::VisitStringLiteral(const StringLiteral *Str) {
1723  VisitExpr(Str);
1724  ColorScope Color(*this, ValueColor);
1725  OS << " ";
1726  Str->outputString(OS);
1727}
1728
1729void ASTDumper::VisitInitListExpr(const InitListExpr *ILE) {
1730  VisitExpr(ILE);
1731  if (auto *Filler = ILE->getArrayFiller()) {
1732    if (!ILE->getNumInits())
1733      lastChild();
1734    IndentScope Indent(*this);
1735    OS << "array filler";
1736    lastChild();
1737    dumpStmt(Filler);
1738  }
1739  if (auto *Field = ILE->getInitializedFieldInUnion()) {
1740    OS << " field ";
1741    dumpBareDeclRef(Field);
1742  }
1743}
1744
1745void ASTDumper::VisitUnaryOperator(const UnaryOperator *Node) {
1746  VisitExpr(Node);
1747  OS << " " << (Node->isPostfix() ? "postfix" : "prefix")
1748     << " '" << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
1749}
1750
1751void ASTDumper::VisitUnaryExprOrTypeTraitExpr(
1752    const UnaryExprOrTypeTraitExpr *Node) {
1753  VisitExpr(Node);
1754  switch(Node->getKind()) {
1755  case UETT_SizeOf:
1756    OS << " sizeof";
1757    break;
1758  case UETT_AlignOf:
1759    OS << " alignof";
1760    break;
1761  case UETT_VecStep:
1762    OS << " vec_step";
1763    break;
1764  }
1765  if (Node->isArgumentType())
1766    dumpType(Node->getArgumentType());
1767}
1768
1769void ASTDumper::VisitMemberExpr(const MemberExpr *Node) {
1770  VisitExpr(Node);
1771  OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
1772  dumpPointer(Node->getMemberDecl());
1773}
1774
1775void ASTDumper::VisitExtVectorElementExpr(const ExtVectorElementExpr *Node) {
1776  VisitExpr(Node);
1777  OS << " " << Node->getAccessor().getNameStart();
1778}
1779
1780void ASTDumper::VisitBinaryOperator(const BinaryOperator *Node) {
1781  VisitExpr(Node);
1782  OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
1783}
1784
1785void ASTDumper::VisitCompoundAssignOperator(
1786    const CompoundAssignOperator *Node) {
1787  VisitExpr(Node);
1788  OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
1789     << "' ComputeLHSTy=";
1790  dumpBareType(Node->getComputationLHSType());
1791  OS << " ComputeResultTy=";
1792  dumpBareType(Node->getComputationResultType());
1793}
1794
1795void ASTDumper::VisitBlockExpr(const BlockExpr *Node) {
1796  VisitExpr(Node);
1797  dumpDecl(Node->getBlockDecl());
1798}
1799
1800void ASTDumper::VisitOpaqueValueExpr(const OpaqueValueExpr *Node) {
1801  VisitExpr(Node);
1802
1803  if (Expr *Source = Node->getSourceExpr()) {
1804    lastChild();
1805    dumpStmt(Source);
1806  }
1807}
1808
1809// GNU extensions.
1810
1811void ASTDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
1812  VisitExpr(Node);
1813  OS << " " << Node->getLabel()->getName();
1814  dumpPointer(Node->getLabel());
1815}
1816
1817//===----------------------------------------------------------------------===//
1818// C++ Expressions
1819//===----------------------------------------------------------------------===//
1820
1821void ASTDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
1822  VisitExpr(Node);
1823  OS << " " << Node->getCastName()
1824     << "<" << Node->getTypeAsWritten().getAsString() << ">"
1825     << " <" << Node->getCastKindName();
1826  dumpBasePath(OS, Node);
1827  OS << ">";
1828}
1829
1830void ASTDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) {
1831  VisitExpr(Node);
1832  OS << " " << (Node->getValue() ? "true" : "false");
1833}
1834
1835void ASTDumper::VisitCXXThisExpr(const CXXThisExpr *Node) {
1836  VisitExpr(Node);
1837  OS << " this";
1838}
1839
1840void ASTDumper::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *Node) {
1841  VisitExpr(Node);
1842  OS << " functional cast to " << Node->getTypeAsWritten().getAsString()
1843     << " <" << Node->getCastKindName() << ">";
1844}
1845
1846void ASTDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
1847  VisitExpr(Node);
1848  CXXConstructorDecl *Ctor = Node->getConstructor();
1849  dumpType(Ctor->getType());
1850  if (Node->isElidable())
1851    OS << " elidable";
1852  if (Node->requiresZeroInitialization())
1853    OS << " zeroing";
1854}
1855
1856void ASTDumper::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *Node) {
1857  VisitExpr(Node);
1858  OS << " ";
1859  dumpCXXTemporary(Node->getTemporary());
1860}
1861
1862void
1863ASTDumper::VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *Node) {
1864  VisitExpr(Node);
1865  if (const ValueDecl *VD = Node->getExtendingDecl()) {
1866    OS << " extended by ";
1867    dumpBareDeclRef(VD);
1868  }
1869}
1870
1871void ASTDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
1872  VisitExpr(Node);
1873  for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
1874    dumpDeclRef(Node->getObject(i), "cleanup");
1875}
1876
1877void ASTDumper::dumpCXXTemporary(const CXXTemporary *Temporary) {
1878  OS << "(CXXTemporary";
1879  dumpPointer(Temporary);
1880  OS << ")";
1881}
1882
1883//===----------------------------------------------------------------------===//
1884// Obj-C Expressions
1885//===----------------------------------------------------------------------===//
1886
1887void ASTDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
1888  VisitExpr(Node);
1889  OS << " selector=";
1890  Node->getSelector().print(OS);
1891  switch (Node->getReceiverKind()) {
1892  case ObjCMessageExpr::Instance:
1893    break;
1894
1895  case ObjCMessageExpr::Class:
1896    OS << " class=";
1897    dumpBareType(Node->getClassReceiver());
1898    break;
1899
1900  case ObjCMessageExpr::SuperInstance:
1901    OS << " super (instance)";
1902    break;
1903
1904  case ObjCMessageExpr::SuperClass:
1905    OS << " super (class)";
1906    break;
1907  }
1908}
1909
1910void ASTDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
1911  VisitExpr(Node);
1912  OS << " selector=";
1913  Node->getBoxingMethod()->getSelector().print(OS);
1914}
1915
1916void ASTDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
1917  VisitStmt(Node);
1918  if (const VarDecl *CatchParam = Node->getCatchParamDecl())
1919    dumpDecl(CatchParam);
1920  else
1921    OS << " catch all";
1922}
1923
1924void ASTDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
1925  VisitExpr(Node);
1926  dumpType(Node->getEncodedType());
1927}
1928
1929void ASTDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
1930  VisitExpr(Node);
1931
1932  OS << " ";
1933  Node->getSelector().print(OS);
1934}
1935
1936void ASTDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) {
1937  VisitExpr(Node);
1938
1939  OS << ' ' << *Node->getProtocol();
1940}
1941
1942void ASTDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) {
1943  VisitExpr(Node);
1944  if (Node->isImplicitProperty()) {
1945    OS << " Kind=MethodRef Getter=\"";
1946    if (Node->getImplicitPropertyGetter())
1947      Node->getImplicitPropertyGetter()->getSelector().print(OS);
1948    else
1949      OS << "(null)";
1950
1951    OS << "\" Setter=\"";
1952    if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter())
1953      Setter->getSelector().print(OS);
1954    else
1955      OS << "(null)";
1956    OS << "\"";
1957  } else {
1958    OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty() <<'"';
1959  }
1960
1961  if (Node->isSuperReceiver())
1962    OS << " super";
1963
1964  OS << " Messaging=";
1965  if (Node->isMessagingGetter() && Node->isMessagingSetter())
1966    OS << "Getter&Setter";
1967  else if (Node->isMessagingGetter())
1968    OS << "Getter";
1969  else if (Node->isMessagingSetter())
1970    OS << "Setter";
1971}
1972
1973void ASTDumper::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *Node) {
1974  VisitExpr(Node);
1975  if (Node->isArraySubscriptRefExpr())
1976    OS << " Kind=ArraySubscript GetterForArray=\"";
1977  else
1978    OS << " Kind=DictionarySubscript GetterForDictionary=\"";
1979  if (Node->getAtIndexMethodDecl())
1980    Node->getAtIndexMethodDecl()->getSelector().print(OS);
1981  else
1982    OS << "(null)";
1983
1984  if (Node->isArraySubscriptRefExpr())
1985    OS << "\" SetterForArray=\"";
1986  else
1987    OS << "\" SetterForDictionary=\"";
1988  if (Node->setAtIndexMethodDecl())
1989    Node->setAtIndexMethodDecl()->getSelector().print(OS);
1990  else
1991    OS << "(null)";
1992}
1993
1994void ASTDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) {
1995  VisitExpr(Node);
1996  OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no");
1997}
1998
1999//===----------------------------------------------------------------------===//
2000// Comments
2001//===----------------------------------------------------------------------===//
2002
2003const char *ASTDumper::getCommandName(unsigned CommandID) {
2004  if (Traits)
2005    return Traits->getCommandInfo(CommandID)->Name;
2006  const CommandInfo *Info = CommandTraits::getBuiltinCommandInfo(CommandID);
2007  if (Info)
2008    return Info->Name;
2009  return "<not a builtin command>";
2010}
2011
2012void ASTDumper::dumpFullComment(const FullComment *C) {
2013  if (!C)
2014    return;
2015
2016  FC = C;
2017  dumpComment(C);
2018  FC = nullptr;
2019}
2020
2021void ASTDumper::dumpComment(const Comment *C) {
2022  IndentScope Indent(*this);
2023
2024  if (!C) {
2025    ColorScope Color(*this, NullColor);
2026    OS << "<<<NULL>>>";
2027    return;
2028  }
2029
2030  {
2031    ColorScope Color(*this, CommentColor);
2032    OS << C->getCommentKindName();
2033  }
2034  dumpPointer(C);
2035  dumpSourceRange(C->getSourceRange());
2036  ConstCommentVisitor<ASTDumper>::visit(C);
2037  for (Comment::child_iterator I = C->child_begin(), E = C->child_end();
2038       I != E; ++I) {
2039    if (I + 1 == E)
2040      lastChild();
2041    dumpComment(*I);
2042  }
2043}
2044
2045void ASTDumper::visitTextComment(const TextComment *C) {
2046  OS << " Text=\"" << C->getText() << "\"";
2047}
2048
2049void ASTDumper::visitInlineCommandComment(const InlineCommandComment *C) {
2050  OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
2051  switch (C->getRenderKind()) {
2052  case InlineCommandComment::RenderNormal:
2053    OS << " RenderNormal";
2054    break;
2055  case InlineCommandComment::RenderBold:
2056    OS << " RenderBold";
2057    break;
2058  case InlineCommandComment::RenderMonospaced:
2059    OS << " RenderMonospaced";
2060    break;
2061  case InlineCommandComment::RenderEmphasized:
2062    OS << " RenderEmphasized";
2063    break;
2064  }
2065
2066  for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
2067    OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
2068}
2069
2070void ASTDumper::visitHTMLStartTagComment(const HTMLStartTagComment *C) {
2071  OS << " Name=\"" << C->getTagName() << "\"";
2072  if (C->getNumAttrs() != 0) {
2073    OS << " Attrs: ";
2074    for (unsigned i = 0, e = C->getNumAttrs(); i != e; ++i) {
2075      const HTMLStartTagComment::Attribute &Attr = C->getAttr(i);
2076      OS << " \"" << Attr.Name << "=\"" << Attr.Value << "\"";
2077    }
2078  }
2079  if (C->isSelfClosing())
2080    OS << " SelfClosing";
2081}
2082
2083void ASTDumper::visitHTMLEndTagComment(const HTMLEndTagComment *C) {
2084  OS << " Name=\"" << C->getTagName() << "\"";
2085}
2086
2087void ASTDumper::visitBlockCommandComment(const BlockCommandComment *C) {
2088  OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
2089  for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
2090    OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
2091}
2092
2093void ASTDumper::visitParamCommandComment(const ParamCommandComment *C) {
2094  OS << " " << ParamCommandComment::getDirectionAsString(C->getDirection());
2095
2096  if (C->isDirectionExplicit())
2097    OS << " explicitly";
2098  else
2099    OS << " implicitly";
2100
2101  if (C->hasParamName()) {
2102    if (C->isParamIndexValid())
2103      OS << " Param=\"" << C->getParamName(FC) << "\"";
2104    else
2105      OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
2106  }
2107
2108  if (C->isParamIndexValid() && !C->isVarArgParam())
2109    OS << " ParamIndex=" << C->getParamIndex();
2110}
2111
2112void ASTDumper::visitTParamCommandComment(const TParamCommandComment *C) {
2113  if (C->hasParamName()) {
2114    if (C->isPositionValid())
2115      OS << " Param=\"" << C->getParamName(FC) << "\"";
2116    else
2117      OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
2118  }
2119
2120  if (C->isPositionValid()) {
2121    OS << " Position=<";
2122    for (unsigned i = 0, e = C->getDepth(); i != e; ++i) {
2123      OS << C->getIndex(i);
2124      if (i != e - 1)
2125        OS << ", ";
2126    }
2127    OS << ">";
2128  }
2129}
2130
2131void ASTDumper::visitVerbatimBlockComment(const VerbatimBlockComment *C) {
2132  OS << " Name=\"" << getCommandName(C->getCommandID()) << "\""
2133        " CloseName=\"" << C->getCloseName() << "\"";
2134}
2135
2136void ASTDumper::visitVerbatimBlockLineComment(
2137    const VerbatimBlockLineComment *C) {
2138  OS << " Text=\"" << C->getText() << "\"";
2139}
2140
2141void ASTDumper::visitVerbatimLineComment(const VerbatimLineComment *C) {
2142  OS << " Text=\"" << C->getText() << "\"";
2143}
2144
2145//===----------------------------------------------------------------------===//
2146// Decl method implementations
2147//===----------------------------------------------------------------------===//
2148
2149LLVM_DUMP_METHOD void Decl::dump() const { dump(llvm::errs()); }
2150
2151LLVM_DUMP_METHOD void Decl::dump(raw_ostream &OS) const {
2152  ASTDumper P(OS, &getASTContext().getCommentCommandTraits(),
2153              &getASTContext().getSourceManager());
2154  P.dumpDecl(this);
2155}
2156
2157LLVM_DUMP_METHOD void Decl::dumpColor() const {
2158  ASTDumper P(llvm::errs(), &getASTContext().getCommentCommandTraits(),
2159              &getASTContext().getSourceManager(), /*ShowColors*/true);
2160  P.dumpDecl(this);
2161}
2162
2163LLVM_DUMP_METHOD void DeclContext::dumpLookups() const {
2164  dumpLookups(llvm::errs());
2165}
2166
2167LLVM_DUMP_METHOD void DeclContext::dumpLookups(raw_ostream &OS) const {
2168  const DeclContext *DC = this;
2169  while (!DC->isTranslationUnit())
2170    DC = DC->getParent();
2171  ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
2172  ASTDumper P(OS, &Ctx.getCommentCommandTraits(), &Ctx.getSourceManager());
2173  P.dumpLookups(this);
2174}
2175
2176//===----------------------------------------------------------------------===//
2177// Stmt method implementations
2178//===----------------------------------------------------------------------===//
2179
2180LLVM_DUMP_METHOD void Stmt::dump(SourceManager &SM) const {
2181  dump(llvm::errs(), SM);
2182}
2183
2184LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS, SourceManager &SM) const {
2185  ASTDumper P(OS, nullptr, &SM);
2186  P.dumpStmt(this);
2187}
2188
2189LLVM_DUMP_METHOD void Stmt::dump() const {
2190  ASTDumper P(llvm::errs(), nullptr, nullptr);
2191  P.dumpStmt(this);
2192}
2193
2194LLVM_DUMP_METHOD void Stmt::dumpColor() const {
2195  ASTDumper P(llvm::errs(), nullptr, nullptr, /*ShowColors*/true);
2196  P.dumpStmt(this);
2197}
2198
2199//===----------------------------------------------------------------------===//
2200// Comment method implementations
2201//===----------------------------------------------------------------------===//
2202
2203LLVM_DUMP_METHOD void Comment::dump() const {
2204  dump(llvm::errs(), nullptr, nullptr);
2205}
2206
2207LLVM_DUMP_METHOD void Comment::dump(const ASTContext &Context) const {
2208  dump(llvm::errs(), &Context.getCommentCommandTraits(),
2209       &Context.getSourceManager());
2210}
2211
2212void Comment::dump(raw_ostream &OS, const CommandTraits *Traits,
2213                   const SourceManager *SM) const {
2214  const FullComment *FC = dyn_cast<FullComment>(this);
2215  ASTDumper D(OS, Traits, SM);
2216  D.dumpFullComment(FC);
2217}
2218
2219LLVM_DUMP_METHOD void Comment::dumpColor() const {
2220  const FullComment *FC = dyn_cast<FullComment>(this);
2221  ASTDumper D(llvm::errs(), nullptr, nullptr, /*ShowColors*/true);
2222  D.dumpFullComment(FC);
2223}
2224