blob: 4a8f88f3282925bead54605909509ad81cd4703b [file] [log] [blame]
Chris Lattner97e8b6f2007-10-07 06:04:32 +00001//===--- ASTConsumers.cpp - ASTConsumer implementations -------------------===//
Reid Spencer5f016e22007-07-11 17:01:13 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
Chris Lattner97e8b6f2007-10-07 06:04:32 +000010// AST Consumer Implementations.
Reid Spencer5f016e22007-07-11 17:01:13 +000011//
12//===----------------------------------------------------------------------===//
13
Eli Friedman39d7c4d2009-05-18 22:50:54 +000014#include "clang/Frontend/ASTConsumers.h"
Alexander Kornienkoe34a0522012-07-26 16:01:23 +000015#include "clang/Basic/FileManager.h"
Nico Weberdae86962008-08-09 18:32:11 +000016#include "clang/Basic/Diagnostic.h"
Ted Kremenek54117722007-12-20 00:34:58 +000017#include "clang/Basic/SourceManager.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000018#include "clang/AST/AST.h"
Chris Lattner3d4997d2007-09-15 23:02:28 +000019#include "clang/AST/ASTConsumer.h"
Chris Lattner557c5b12009-03-28 04:27:18 +000020#include "clang/AST/ASTContext.h"
Douglas Gregord249e1d1f2009-05-29 20:38:28 +000021#include "clang/AST/PrettyPrinter.h"
Alexander Kornienkoe34a0522012-07-26 16:01:23 +000022#include "clang/AST/RecordLayout.h"
23#include "clang/AST/RecursiveASTVisitor.h"
Ted Kremenek815c78f2008-08-05 18:50:11 +000024#include "llvm/Module.h"
Michael J. Spencer03013fa2010-11-29 18:12:39 +000025#include "llvm/Support/Path.h"
Alexander Kornienkoe34a0522012-07-26 16:01:23 +000026#include "llvm/Support/raw_ostream.h"
27#include "llvm/Support/Timer.h"
Chris Lattner6000dac2007-08-08 22:51:59 +000028using namespace clang;
Reid Spencer5f016e22007-07-11 17:01:13 +000029
Ted Kremenek1b5a4bd2007-11-27 21:46:50 +000030//===----------------------------------------------------------------------===//
Douglas Gregor4fe0c8e2009-05-30 00:08:05 +000031/// ASTPrinter - Pretty-printer and dumper of ASTs
Chris Lattner6000dac2007-08-08 22:51:59 +000032
Ted Kremenek1b5a4bd2007-11-27 21:46:50 +000033namespace {
Alexander Kornienkoe34a0522012-07-26 16:01:23 +000034 class ASTPrinter : public ASTConsumer,
35 public RecursiveASTVisitor<ASTPrinter> {
36 typedef RecursiveASTVisitor<ASTPrinter> base;
Mike Stump1eb44332009-09-09 15:08:12 +000037
Ted Kremenek1b5a4bd2007-11-27 21:46:50 +000038 public:
Alexander Kornienkoe34a0522012-07-26 16:01:23 +000039 ASTPrinter(raw_ostream *Out = NULL, bool Dump = false,
40 StringRef FilterString = "")
41 : Out(Out ? *Out : llvm::outs()), Dump(Dump),
42 FilterString(FilterString) {}
Mike Stump1eb44332009-09-09 15:08:12 +000043
Douglas Gregor4fe0c8e2009-05-30 00:08:05 +000044 virtual void HandleTranslationUnit(ASTContext &Context) {
Alexander Kornienkoe34a0522012-07-26 16:01:23 +000045 TranslationUnitDecl *D = Context.getTranslationUnitDecl();
46
47 if (FilterString.empty()) {
48 if (Dump)
49 D->dump(Out);
50 else
51 D->print(Out, /*Indentation=*/0, /*PrintInstantiation=*/true);
52 return;
53 }
54
55 TraverseDecl(D);
Reid Spencer5f016e22007-07-11 17:01:13 +000056 }
Alexander Kornienkoe34a0522012-07-26 16:01:23 +000057
58 bool shouldWalkTypesOfTypeLocs() const { return false; }
59
60 bool TraverseDecl(Decl *D) {
Alexander Kornienkoa7612ae2012-08-17 17:38:39 +000061 if (D == NULL)
62 return false;
Alexander Kornienkoe34a0522012-07-26 16:01:23 +000063 if (filterMatches(D)) {
64 Out.changeColor(llvm::raw_ostream::BLUE) <<
65 (Dump ? "Dumping " : "Printing ") << getName(D) << ":\n";
66 Out.resetColor();
67 if (Dump)
68 D->dump(Out);
69 else
70 D->print(Out, /*Indentation=*/0, /*PrintInstantiation=*/true);
Alexander Kornienkoa7612ae2012-08-17 17:38:39 +000071 Out << "\n";
Alexander Kornienkoe34a0522012-07-26 16:01:23 +000072 // Don't traverse child nodes to avoid output duplication.
73 return true;
74 }
75 return base::TraverseDecl(D);
76 }
77
78 private:
79 std::string getName(Decl *D) {
80 if (isa<NamedDecl>(D))
81 return cast<NamedDecl>(D)->getQualifiedNameAsString();
82 return "";
83 }
84 bool filterMatches(Decl *D) {
85 return getName(D).find(FilterString) != std::string::npos;
86 }
87
88 raw_ostream &Out;
89 bool Dump;
90 std::string FilterString;
Chris Lattner3d4997d2007-09-15 23:02:28 +000091 };
Alexander Kornienko171af642012-07-31 09:37:40 +000092
93 class ASTDeclNodeLister : public ASTConsumer,
94 public RecursiveASTVisitor<ASTDeclNodeLister> {
Alexander Kornienko171af642012-07-31 09:37:40 +000095 public:
96 ASTDeclNodeLister(raw_ostream *Out = NULL)
97 : Out(Out ? *Out : llvm::outs()) {}
98
99 virtual void HandleTranslationUnit(ASTContext &Context) {
100 TraverseDecl(Context.getTranslationUnitDecl());
101 }
102
103 bool shouldWalkTypesOfTypeLocs() const { return false; }
104
105 virtual bool VisitNamedDecl(NamedDecl *D) {
106 Out << D->getQualifiedNameAsString() << "\n";
107 return true;
108 }
109
110 private:
111 raw_ostream &Out;
112 };
Chris Lattnerb23ff6b2009-03-28 05:44:17 +0000113} // end anonymous namespace
Chris Lattner6000dac2007-08-08 22:51:59 +0000114
Alexander Kornienkoe34a0522012-07-26 16:01:23 +0000115ASTConsumer *clang::CreateASTPrinter(raw_ostream *Out,
116 StringRef FilterString) {
117 return new ASTPrinter(Out, /*Dump=*/ false, FilterString);
Ted Kremenekea75c552007-11-28 21:32:21 +0000118}
Ted Kremenek1b5a4bd2007-11-27 21:46:50 +0000119
Alexander Kornienkoe34a0522012-07-26 16:01:23 +0000120ASTConsumer *clang::CreateASTDumper(StringRef FilterString) {
121 return new ASTPrinter(0, /*Dump=*/ true, FilterString);
Douglas Gregor609e72f2009-04-26 02:02:08 +0000122}
Chris Lattner3d4997d2007-09-15 23:02:28 +0000123
Alexander Kornienko171af642012-07-31 09:37:40 +0000124ASTConsumer *clang::CreateASTDeclNodeLister() {
125 return new ASTDeclNodeLister(0);
126}
127
Ted Kremenek1b5a4bd2007-11-27 21:46:50 +0000128//===----------------------------------------------------------------------===//
129/// ASTViewer - AST Visualization
130
Ted Kremenek80de08f2007-09-19 21:29:43 +0000131namespace {
132 class ASTViewer : public ASTConsumer {
Douglas Gregor4fe0c8e2009-05-30 00:08:05 +0000133 ASTContext *Context;
Ted Kremenek80de08f2007-09-19 21:29:43 +0000134 public:
Ted Kremenek95041a22007-12-19 22:51:13 +0000135 void Initialize(ASTContext &Context) {
Douglas Gregor4fe0c8e2009-05-30 00:08:05 +0000136 this->Context = &Context;
Ted Kremenek80de08f2007-09-19 21:29:43 +0000137 }
Chris Lattner682bf922009-03-29 16:50:03 +0000138
Argyrios Kyrtzidis88c25962011-11-18 00:26:59 +0000139 virtual bool HandleTopLevelDecl(DeclGroupRef D) {
Chris Lattner682bf922009-03-29 16:50:03 +0000140 for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I)
141 HandleTopLevelSingleDecl(*I);
Argyrios Kyrtzidis88c25962011-11-18 00:26:59 +0000142 return true;
Chris Lattner682bf922009-03-29 16:50:03 +0000143 }
Mike Stump1eb44332009-09-09 15:08:12 +0000144
Chris Lattner682bf922009-03-29 16:50:03 +0000145 void HandleTopLevelSingleDecl(Decl *D);
Ted Kremenek80de08f2007-09-19 21:29:43 +0000146 };
147}
148
Chris Lattner682bf922009-03-29 16:50:03 +0000149void ASTViewer::HandleTopLevelSingleDecl(Decl *D) {
Argyrios Kyrtzidis9d96f922010-07-07 11:31:23 +0000150 if (isa<FunctionDecl>(D) || isa<ObjCMethodDecl>(D)) {
151 D->print(llvm::errs());
152
153 if (Stmt *Body = D->getBody()) {
Benjamin Kramer6cb7c1a2009-08-23 12:08:50 +0000154 llvm::errs() << '\n';
Douglas Gregoraf3280f2009-09-12 00:08:48 +0000155 Body->viewAST();
Benjamin Kramer6cb7c1a2009-08-23 12:08:50 +0000156 llvm::errs() << '\n';
Chris Lattnerb23ff6b2009-03-28 05:44:17 +0000157 }
Chris Lattnerb23ff6b2009-03-28 05:44:17 +0000158 }
159}
160
161
Ted Kremenek80de08f2007-09-19 21:29:43 +0000162ASTConsumer *clang::CreateASTViewer() { return new ASTViewer(); }
163
Ted Kremenek74bf2c92007-09-07 23:47:56 +0000164//===----------------------------------------------------------------------===//
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000165/// DeclContextPrinter - Decl and DeclContext Visualization
166
167namespace {
168
169class DeclContextPrinter : public ASTConsumer {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000170 raw_ostream& Out;
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000171public:
172 DeclContextPrinter() : Out(llvm::errs()) {}
173
Chris Lattnerdacbc5d2009-03-28 04:11:33 +0000174 void HandleTranslationUnit(ASTContext &C) {
175 PrintDeclContext(C.getTranslationUnitDecl(), 4);
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000176 }
177
178 void PrintDeclContext(const DeclContext* DC, unsigned Indentation);
179};
Chris Lattnerb23ff6b2009-03-28 05:44:17 +0000180} // end anonymous namespace
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000181
Mike Stump1eb44332009-09-09 15:08:12 +0000182void DeclContextPrinter::PrintDeclContext(const DeclContext* DC,
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000183 unsigned Indentation) {
184 // Print DeclContext name.
Argyrios Kyrtzidis9b9ca012009-01-13 13:11:58 +0000185 switch (DC->getDeclKind()) {
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000186 case Decl::TranslationUnit:
187 Out << "[translation unit] " << DC;
188 break;
189 case Decl::Namespace: {
190 Out << "[namespace] ";
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000191 const NamespaceDecl* ND = cast<NamespaceDecl>(DC);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000192 Out << *ND;
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000193 break;
194 }
Zhongxing Xu867c39e2009-01-13 02:41:08 +0000195 case Decl::Enum: {
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000196 const EnumDecl* ED = cast<EnumDecl>(DC);
John McCall5e1cdac2011-10-07 06:10:15 +0000197 if (ED->isCompleteDefinition())
Zhongxing Xu867c39e2009-01-13 02:41:08 +0000198 Out << "[enum] ";
199 else
200 Out << "<enum> ";
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000201 Out << *ED;
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000202 break;
Zhongxing Xu867c39e2009-01-13 02:41:08 +0000203 }
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000204 case Decl::Record: {
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000205 const RecordDecl* RD = cast<RecordDecl>(DC);
John McCall5e1cdac2011-10-07 06:10:15 +0000206 if (RD->isCompleteDefinition())
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000207 Out << "[struct] ";
208 else
209 Out << "<struct> ";
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000210 Out << *RD;
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000211 break;
212 }
213 case Decl::CXXRecord: {
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000214 const CXXRecordDecl* RD = cast<CXXRecordDecl>(DC);
John McCall5e1cdac2011-10-07 06:10:15 +0000215 if (RD->isCompleteDefinition())
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000216 Out << "[class] ";
217 else
218 Out << "<class> ";
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000219 Out << *RD << ' ' << DC;
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000220 break;
221 }
222 case Decl::ObjCMethod:
223 Out << "[objc method]";
224 break;
225 case Decl::ObjCInterface:
226 Out << "[objc interface]";
227 break;
228 case Decl::ObjCCategory:
229 Out << "[objc category]";
230 break;
231 case Decl::ObjCProtocol:
232 Out << "[objc protocol]";
233 break;
234 case Decl::ObjCImplementation:
235 Out << "[objc implementation]";
236 break;
237 case Decl::ObjCCategoryImpl:
238 Out << "[objc categoryimpl]";
239 break;
240 case Decl::LinkageSpec:
241 Out << "[linkage spec]";
242 break;
243 case Decl::Block:
244 Out << "[block]";
245 break;
246 case Decl::Function: {
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000247 const FunctionDecl* FD = cast<FunctionDecl>(DC);
Sean Hunt10620eb2011-05-06 20:44:56 +0000248 if (FD->doesThisDeclarationHaveABody())
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000249 Out << "[function] ";
250 else
251 Out << "<function> ";
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000252 Out << *FD;
Zhongxing Xuca04ce42009-01-13 06:25:33 +0000253 // Print the parameters.
254 Out << "(";
255 bool PrintComma = false;
Mike Stump1eb44332009-09-09 15:08:12 +0000256 for (FunctionDecl::param_const_iterator I = FD->param_begin(),
Zhongxing Xuca04ce42009-01-13 06:25:33 +0000257 E = FD->param_end(); I != E; ++I) {
258 if (PrintComma)
259 Out << ", ";
260 else
261 PrintComma = true;
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000262 Out << **I;
Zhongxing Xuca04ce42009-01-13 06:25:33 +0000263 }
264 Out << ")";
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000265 break;
266 }
267 case Decl::CXXMethod: {
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000268 const CXXMethodDecl* D = cast<CXXMethodDecl>(DC);
Argyrios Kyrtzidisf5cecfb2009-06-17 22:49:50 +0000269 if (D->isOutOfLine())
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000270 Out << "[c++ method] ";
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000271 else if (D->isImplicit())
272 Out << "(c++ method) ";
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000273 else
274 Out << "<c++ method> ";
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000275 Out << *D;
Zhongxing Xuca04ce42009-01-13 06:25:33 +0000276 // Print the parameters.
277 Out << "(";
278 bool PrintComma = false;
Mike Stump1eb44332009-09-09 15:08:12 +0000279 for (FunctionDecl::param_const_iterator I = D->param_begin(),
Zhongxing Xuca04ce42009-01-13 06:25:33 +0000280 E = D->param_end(); I != E; ++I) {
281 if (PrintComma)
282 Out << ", ";
283 else
284 PrintComma = true;
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000285 Out << **I;
Zhongxing Xuca04ce42009-01-13 06:25:33 +0000286 }
287 Out << ")";
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000288
289 // Check the semantic DeclContext.
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000290 const DeclContext* SemaDC = D->getDeclContext();
291 const DeclContext* LexicalDC = D->getLexicalDeclContext();
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000292 if (SemaDC != LexicalDC)
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000293 Out << " [[" << SemaDC << "]]";
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000294
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000295 break;
296 }
297 case Decl::CXXConstructor: {
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000298 const CXXConstructorDecl* D = cast<CXXConstructorDecl>(DC);
Argyrios Kyrtzidisf5cecfb2009-06-17 22:49:50 +0000299 if (D->isOutOfLine())
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000300 Out << "[c++ ctor] ";
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000301 else if (D->isImplicit())
302 Out << "(c++ ctor) ";
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000303 else
304 Out << "<c++ ctor> ";
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000305 Out << *D;
Zhongxing Xuca04ce42009-01-13 06:25:33 +0000306 // Print the parameters.
307 Out << "(";
308 bool PrintComma = false;
Mike Stump1eb44332009-09-09 15:08:12 +0000309 for (FunctionDecl::param_const_iterator I = D->param_begin(),
Zhongxing Xuca04ce42009-01-13 06:25:33 +0000310 E = D->param_end(); I != E; ++I) {
311 if (PrintComma)
312 Out << ", ";
313 else
314 PrintComma = true;
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000315 Out << **I;
Zhongxing Xuca04ce42009-01-13 06:25:33 +0000316 }
317 Out << ")";
318
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000319 // Check the semantic DC.
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000320 const DeclContext* SemaDC = D->getDeclContext();
321 const DeclContext* LexicalDC = D->getLexicalDeclContext();
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000322 if (SemaDC != LexicalDC)
323 Out << " [[" << SemaDC << "]]";
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000324 break;
325 }
326 case Decl::CXXDestructor: {
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000327 const CXXDestructorDecl* D = cast<CXXDestructorDecl>(DC);
Argyrios Kyrtzidisf5cecfb2009-06-17 22:49:50 +0000328 if (D->isOutOfLine())
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000329 Out << "[c++ dtor] ";
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000330 else if (D->isImplicit())
331 Out << "(c++ dtor) ";
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000332 else
333 Out << "<c++ dtor> ";
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000334 Out << *D;
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000335 // Check the semantic DC.
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000336 const DeclContext* SemaDC = D->getDeclContext();
337 const DeclContext* LexicalDC = D->getLexicalDeclContext();
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000338 if (SemaDC != LexicalDC)
339 Out << " [[" << SemaDC << "]]";
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000340 break;
341 }
342 case Decl::CXXConversion: {
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000343 const CXXConversionDecl* D = cast<CXXConversionDecl>(DC);
Argyrios Kyrtzidisf5cecfb2009-06-17 22:49:50 +0000344 if (D->isOutOfLine())
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000345 Out << "[c++ conversion] ";
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000346 else if (D->isImplicit())
347 Out << "(c++ conversion) ";
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000348 else
349 Out << "<c++ conversion> ";
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000350 Out << *D;
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000351 // Check the semantic DC.
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000352 const DeclContext* SemaDC = D->getDeclContext();
353 const DeclContext* LexicalDC = D->getLexicalDeclContext();
Zhongxing Xu2a3eb0e2009-01-13 03:26:38 +0000354 if (SemaDC != LexicalDC)
355 Out << " [[" << SemaDC << "]]";
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000356 break;
357 }
358
359 default:
David Blaikieb219cfc2011-09-23 05:06:16 +0000360 llvm_unreachable("a decl that inherits DeclContext isn't handled");
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000361 }
362
363 Out << "\n";
364
365 // Print decls in the DeclContext.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000366 for (DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end();
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000367 I != E; ++I) {
368 for (unsigned i = 0; i < Indentation; ++i)
Mike Stump071e4da2009-02-10 20:16:46 +0000369 Out << " ";
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000370
371 Decl::Kind DK = I->getKind();
372 switch (DK) {
373 case Decl::Namespace:
374 case Decl::Enum:
375 case Decl::Record:
376 case Decl::CXXRecord:
377 case Decl::ObjCMethod:
378 case Decl::ObjCInterface:
Mike Stump1eb44332009-09-09 15:08:12 +0000379 case Decl::ObjCCategory:
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000380 case Decl::ObjCProtocol:
381 case Decl::ObjCImplementation:
382 case Decl::ObjCCategoryImpl:
383 case Decl::LinkageSpec:
384 case Decl::Block:
385 case Decl::Function:
386 case Decl::CXXMethod:
387 case Decl::CXXConstructor:
388 case Decl::CXXDestructor:
389 case Decl::CXXConversion:
390 {
Argyrios Kyrtzidis7ad5bf32009-02-16 14:29:59 +0000391 DeclContext* DC = cast<DeclContext>(*I);
Mike Stump071e4da2009-02-10 20:16:46 +0000392 PrintDeclContext(DC, Indentation+2);
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000393 break;
394 }
Francois Picheta3d39c02010-12-21 03:08:02 +0000395 case Decl::IndirectField: {
396 IndirectFieldDecl* IFD = cast<IndirectFieldDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000397 Out << "<IndirectField> " << *IFD << '\n';
Francois Picheta3d39c02010-12-21 03:08:02 +0000398 break;
399 }
Chris Lattner21ac10d2011-02-18 00:52:55 +0000400 case Decl::Label: {
401 LabelDecl *LD = cast<LabelDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000402 Out << "<Label> " << *LD << '\n';
Chris Lattner21ac10d2011-02-18 00:52:55 +0000403 break;
404 }
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000405 case Decl::Field: {
Chris Lattner21ac10d2011-02-18 00:52:55 +0000406 FieldDecl *FD = cast<FieldDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000407 Out << "<field> " << *FD << '\n';
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000408 break;
409 }
Richard Smith162e1c12011-04-15 14:24:37 +0000410 case Decl::Typedef:
411 case Decl::TypeAlias: {
412 TypedefNameDecl* TD = cast<TypedefNameDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000413 Out << "<typedef> " << *TD << '\n';
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000414 break;
415 }
416 case Decl::EnumConstant: {
417 EnumConstantDecl* ECD = cast<EnumConstantDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000418 Out << "<enum constant> " << *ECD << '\n';
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000419 break;
420 }
421 case Decl::Var: {
422 VarDecl* VD = cast<VarDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000423 Out << "<var> " << *VD << '\n';
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000424 break;
425 }
426 case Decl::ImplicitParam: {
427 ImplicitParamDecl* IPD = cast<ImplicitParamDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000428 Out << "<implicit parameter> " << *IPD << '\n';
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000429 break;
430 }
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000431 case Decl::ParmVar: {
432 ParmVarDecl* PVD = cast<ParmVarDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000433 Out << "<parameter> " << *PVD << '\n';
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000434 break;
435 }
436 case Decl::ObjCProperty: {
437 ObjCPropertyDecl* OPD = cast<ObjCPropertyDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000438 Out << "<objc property> " << *OPD << '\n';
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000439 break;
440 }
Eli Friedman7ac1c9e2009-12-08 06:22:37 +0000441 case Decl::FunctionTemplate: {
442 FunctionTemplateDecl* FTD = cast<FunctionTemplateDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000443 Out << "<function template> " << *FTD << '\n';
Eli Friedman7ac1c9e2009-12-08 06:22:37 +0000444 break;
445 }
Eli Friedman368a55d2010-01-03 02:01:11 +0000446 case Decl::FileScopeAsm: {
447 Out << "<file-scope asm>\n";
448 break;
449 }
450 case Decl::UsingDirective: {
451 Out << "<using directive>\n";
452 break;
453 }
454 case Decl::NamespaceAlias: {
455 NamespaceAliasDecl* NAD = cast<NamespaceAliasDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000456 Out << "<namespace alias> " << *NAD << '\n';
Eli Friedman368a55d2010-01-03 02:01:11 +0000457 break;
458 }
Zhongxing Xu2f3cd9c2010-01-20 03:21:28 +0000459 case Decl::ClassTemplate: {
460 ClassTemplateDecl *CTD = cast<ClassTemplateDecl>(*I);
Benjamin Kramerb8989f22011-10-14 18:45:37 +0000461 Out << "<class template> " << *CTD << '\n';
Zhongxing Xu2f3cd9c2010-01-20 03:21:28 +0000462 break;
463 }
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000464 default:
Benjamin Kramer900fc632010-04-17 09:33:03 +0000465 Out << "DeclKind: " << DK << '"' << *I << "\"\n";
David Blaikieb219cfc2011-09-23 05:06:16 +0000466 llvm_unreachable("decl unhandled");
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000467 }
468 }
469}
Mike Stump1eb44332009-09-09 15:08:12 +0000470ASTConsumer *clang::CreateDeclContextPrinter() {
471 return new DeclContextPrinter();
Zhongxing Xu2d75d6f2009-01-13 01:29:24 +0000472}
473
474//===----------------------------------------------------------------------===//
John McCallf3514242010-11-24 11:21:45 +0000475/// ASTDumperXML - In-depth XML dumping.
476
477namespace {
478class ASTDumpXML : public ASTConsumer {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000479 raw_ostream &OS;
John McCallf3514242010-11-24 11:21:45 +0000480
481public:
Chris Lattner5f9e2722011-07-23 10:55:15 +0000482 ASTDumpXML(raw_ostream &OS) : OS(OS) {}
John McCallf3514242010-11-24 11:21:45 +0000483
484 void HandleTranslationUnit(ASTContext &C) {
485 C.getTranslationUnitDecl()->dumpXML(OS);
486 }
487};
488}
489
Chris Lattner5f9e2722011-07-23 10:55:15 +0000490ASTConsumer *clang::CreateASTDumperXML(raw_ostream &OS) {
John McCallf3514242010-11-24 11:21:45 +0000491 return new ASTDumpXML(OS);
492}