blob: 9f6300a114a9864e812694f49290af88c9a00eb4 [file] [log] [blame]
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001//===- CIndex.cpp - Clang-C Source Indexing Library -----------------------===//
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 main API hooks in the Clang-C Source Indexing
11// library.
12//
13//===----------------------------------------------------------------------===//
14
15#include "CIndexer.h"
16#include "CIndexDiagnostic.h"
Chandler Carruthb1ba0ef2013-01-19 08:09:44 +000017#include "CLog.h"
Guy Benyei7f92f2d2012-12-18 14:30:41 +000018#include "CXComment.h"
19#include "CXCursor.h"
20#include "CXSourceLocation.h"
21#include "CXString.h"
22#include "CXTranslationUnit.h"
23#include "CXType.h"
24#include "CursorVisitor.h"
Fariborz Jahanian88b95212012-12-18 23:02:59 +000025#include "SimpleFormatContext.h"
Guy Benyei7f92f2d2012-12-18 14:30:41 +000026#include "clang/AST/StmtVisitor.h"
27#include "clang/Basic/Diagnostic.h"
28#include "clang/Basic/Version.h"
29#include "clang/Frontend/ASTUnit.h"
30#include "clang/Frontend/CompilerInstance.h"
31#include "clang/Frontend/FrontendDiagnostic.h"
32#include "clang/Lex/HeaderSearch.h"
33#include "clang/Lex/Lexer.h"
34#include "clang/Lex/PreprocessingRecord.h"
35#include "clang/Lex/Preprocessor.h"
36#include "llvm/ADT/Optional.h"
37#include "llvm/ADT/STLExtras.h"
38#include "llvm/ADT/StringSwitch.h"
Chandler Carruthb1ba0ef2013-01-19 08:09:44 +000039#include "llvm/Config/config.h"
Guy Benyei7f92f2d2012-12-18 14:30:41 +000040#include "llvm/Support/Compiler.h"
41#include "llvm/Support/CrashRecoveryContext.h"
Chandler Carruthb1ba0ef2013-01-19 08:09:44 +000042#include "llvm/Support/Format.h"
Guy Benyei7f92f2d2012-12-18 14:30:41 +000043#include "llvm/Support/MemoryBuffer.h"
44#include "llvm/Support/Mutex.h"
45#include "llvm/Support/PrettyStackTrace.h"
46#include "llvm/Support/Program.h"
47#include "llvm/Support/SaveAndRestore.h"
48#include "llvm/Support/Signals.h"
49#include "llvm/Support/Threading.h"
50#include "llvm/Support/Timer.h"
51#include "llvm/Support/raw_ostream.h"
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +000052
53#if HAVE_PTHREAD_H
54#include <pthread.h>
55#endif
Guy Benyei7f92f2d2012-12-18 14:30:41 +000056
57using namespace clang;
58using namespace clang::cxcursor;
Guy Benyei7f92f2d2012-12-18 14:30:41 +000059using namespace clang::cxtu;
60using namespace clang::cxindex;
61
Dmitri Gribenkoe42e5782013-01-26 21:32:42 +000062CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx, ASTUnit *AU) {
63 if (!AU)
Guy Benyei7f92f2d2012-12-18 14:30:41 +000064 return 0;
65 CXTranslationUnit D = new CXTranslationUnitImpl();
66 D->CIdx = CIdx;
Dmitri Gribenkoe42e5782013-01-26 21:32:42 +000067 D->TheASTUnit = AU;
Dmitri Gribenkoaca3e562013-02-03 13:52:47 +000068 D->StringPool = new cxstring::CXStringPool();
Guy Benyei7f92f2d2012-12-18 14:30:41 +000069 D->Diagnostics = 0;
70 D->OverridenCursorsPool = createOverridenCXCursorsPool();
Fariborz Jahanian88b95212012-12-18 23:02:59 +000071 D->FormatContext = 0;
72 D->FormatInMemoryUniqueId = 0;
Guy Benyei7f92f2d2012-12-18 14:30:41 +000073 return D;
74}
75
76cxtu::CXTUOwner::~CXTUOwner() {
77 if (TU)
78 clang_disposeTranslationUnit(TU);
79}
80
81/// \brief Compare two source ranges to determine their relative position in
82/// the translation unit.
83static RangeComparisonResult RangeCompare(SourceManager &SM,
84 SourceRange R1,
85 SourceRange R2) {
86 assert(R1.isValid() && "First range is invalid?");
87 assert(R2.isValid() && "Second range is invalid?");
88 if (R1.getEnd() != R2.getBegin() &&
89 SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin()))
90 return RangeBefore;
91 if (R2.getEnd() != R1.getBegin() &&
92 SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin()))
93 return RangeAfter;
94 return RangeOverlap;
95}
96
97/// \brief Determine if a source location falls within, before, or after a
98/// a given source range.
99static RangeComparisonResult LocationCompare(SourceManager &SM,
100 SourceLocation L, SourceRange R) {
101 assert(R.isValid() && "First range is invalid?");
102 assert(L.isValid() && "Second range is invalid?");
103 if (L == R.getBegin() || L == R.getEnd())
104 return RangeOverlap;
105 if (SM.isBeforeInTranslationUnit(L, R.getBegin()))
106 return RangeBefore;
107 if (SM.isBeforeInTranslationUnit(R.getEnd(), L))
108 return RangeAfter;
109 return RangeOverlap;
110}
111
112/// \brief Translate a Clang source range into a CIndex source range.
113///
114/// Clang internally represents ranges where the end location points to the
115/// start of the token at the end. However, for external clients it is more
116/// useful to have a CXSourceRange be a proper half-open interval. This routine
117/// does the appropriate translation.
118CXSourceRange cxloc::translateSourceRange(const SourceManager &SM,
119 const LangOptions &LangOpts,
120 const CharSourceRange &R) {
121 // We want the last character in this location, so we will adjust the
122 // location accordingly.
123 SourceLocation EndLoc = R.getEnd();
124 if (EndLoc.isValid() && EndLoc.isMacroID() && !SM.isMacroArgExpansion(EndLoc))
125 EndLoc = SM.getExpansionRange(EndLoc).second;
126 if (R.isTokenRange() && !EndLoc.isInvalid()) {
127 unsigned Length = Lexer::MeasureTokenLength(SM.getSpellingLoc(EndLoc),
128 SM, LangOpts);
129 EndLoc = EndLoc.getLocWithOffset(Length);
130 }
131
Bill Wendlingccdfdd72013-01-23 08:25:41 +0000132 CXSourceRange Result = {
Dmitri Gribenkoe4ea8792013-01-23 15:56:07 +0000133 { &SM, &LangOpts },
Bill Wendlingccdfdd72013-01-23 08:25:41 +0000134 R.getBegin().getRawEncoding(),
135 EndLoc.getRawEncoding()
136 };
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000137 return Result;
138}
139
140//===----------------------------------------------------------------------===//
141// Cursor visitor.
142//===----------------------------------------------------------------------===//
143
144static SourceRange getRawCursorExtent(CXCursor C);
145static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr);
146
147
148RangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) {
149 return RangeCompare(AU->getSourceManager(), R, RegionOfInterest);
150}
151
152/// \brief Visit the given cursor and, if requested by the visitor,
153/// its children.
154///
155/// \param Cursor the cursor to visit.
156///
157/// \param CheckedRegionOfInterest if true, then the caller already checked
158/// that this cursor is within the region of interest.
159///
160/// \returns true if the visitation should be aborted, false if it
161/// should continue.
162bool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) {
163 if (clang_isInvalid(Cursor.kind))
164 return false;
165
166 if (clang_isDeclaration(Cursor.kind)) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +0000167 const Decl *D = getCursorDecl(Cursor);
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000168 if (!D) {
169 assert(0 && "Invalid declaration cursor");
170 return true; // abort.
171 }
172
173 // Ignore implicit declarations, unless it's an objc method because
174 // currently we should report implicit methods for properties when indexing.
175 if (D->isImplicit() && !isa<ObjCMethodDecl>(D))
176 return false;
177 }
178
179 // If we have a range of interest, and this cursor doesn't intersect with it,
180 // we're done.
181 if (RegionOfInterest.isValid() && !CheckedRegionOfInterest) {
182 SourceRange Range = getRawCursorExtent(Cursor);
183 if (Range.isInvalid() || CompareRegionOfInterest(Range))
184 return false;
185 }
186
187 switch (Visitor(Cursor, Parent, ClientData)) {
188 case CXChildVisit_Break:
189 return true;
190
191 case CXChildVisit_Continue:
192 return false;
193
194 case CXChildVisit_Recurse: {
195 bool ret = VisitChildren(Cursor);
196 if (PostChildrenVisitor)
197 if (PostChildrenVisitor(Cursor, ClientData))
198 return true;
199 return ret;
200 }
201 }
202
203 llvm_unreachable("Invalid CXChildVisitResult!");
204}
205
206static bool visitPreprocessedEntitiesInRange(SourceRange R,
207 PreprocessingRecord &PPRec,
208 CursorVisitor &Visitor) {
209 SourceManager &SM = Visitor.getASTUnit()->getSourceManager();
210 FileID FID;
211
212 if (!Visitor.shouldVisitIncludedEntities()) {
213 // If the begin/end of the range lie in the same FileID, do the optimization
214 // where we skip preprocessed entities that do not come from the same FileID.
215 FID = SM.getFileID(SM.getFileLoc(R.getBegin()));
216 if (FID != SM.getFileID(SM.getFileLoc(R.getEnd())))
217 FID = FileID();
218 }
219
220 std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator>
221 Entities = PPRec.getPreprocessedEntitiesInRange(R);
222 return Visitor.visitPreprocessedEntities(Entities.first, Entities.second,
223 PPRec, FID);
224}
225
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000226bool CursorVisitor::visitFileRegion() {
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000227 if (RegionOfInterest.isInvalid())
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000228 return false;
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000229
Dmitri Gribenko5694feb2013-01-26 18:53:38 +0000230 ASTUnit *Unit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000231 SourceManager &SM = Unit->getSourceManager();
232
233 std::pair<FileID, unsigned>
234 Begin = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getBegin())),
235 End = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getEnd()));
236
237 if (End.first != Begin.first) {
238 // If the end does not reside in the same file, try to recover by
239 // picking the end of the file of begin location.
240 End.first = Begin.first;
241 End.second = SM.getFileIDSize(Begin.first);
242 }
243
244 assert(Begin.first == End.first);
245 if (Begin.second > End.second)
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000246 return false;
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000247
248 FileID File = Begin.first;
249 unsigned Offset = Begin.second;
250 unsigned Length = End.second - Begin.second;
251
252 if (!VisitDeclsOnly && !VisitPreprocessorLast)
253 if (visitPreprocessedEntitiesInRegion())
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000254 return true; // visitation break.
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000255
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000256 if (visitDeclsFromFileRegion(File, Offset, Length))
257 return true; // visitation break.
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000258
259 if (!VisitDeclsOnly && VisitPreprocessorLast)
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000260 return visitPreprocessedEntitiesInRegion();
261
262 return false;
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000263}
264
265static bool isInLexicalContext(Decl *D, DeclContext *DC) {
266 if (!DC)
267 return false;
268
269 for (DeclContext *DeclDC = D->getLexicalDeclContext();
270 DeclDC; DeclDC = DeclDC->getLexicalParent()) {
271 if (DeclDC == DC)
272 return true;
273 }
274 return false;
275}
276
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000277bool CursorVisitor::visitDeclsFromFileRegion(FileID File,
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000278 unsigned Offset, unsigned Length) {
Dmitri Gribenko5694feb2013-01-26 18:53:38 +0000279 ASTUnit *Unit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000280 SourceManager &SM = Unit->getSourceManager();
281 SourceRange Range = RegionOfInterest;
282
283 SmallVector<Decl *, 16> Decls;
284 Unit->findFileRegionDecls(File, Offset, Length, Decls);
285
286 // If we didn't find any file level decls for the file, try looking at the
287 // file that it was included from.
288 while (Decls.empty() || Decls.front()->isTopLevelDeclInObjCContainer()) {
289 bool Invalid = false;
290 const SrcMgr::SLocEntry &SLEntry = SM.getSLocEntry(File, &Invalid);
291 if (Invalid)
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000292 return false;
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000293
294 SourceLocation Outer;
295 if (SLEntry.isFile())
296 Outer = SLEntry.getFile().getIncludeLoc();
297 else
298 Outer = SLEntry.getExpansion().getExpansionLocStart();
299 if (Outer.isInvalid())
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000300 return false;
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000301
302 llvm::tie(File, Offset) = SM.getDecomposedExpansionLoc(Outer);
303 Length = 0;
304 Unit->findFileRegionDecls(File, Offset, Length, Decls);
305 }
306
307 assert(!Decls.empty());
308
309 bool VisitedAtLeastOnce = false;
310 DeclContext *CurDC = 0;
Craig Topper09d19ef2013-07-04 03:08:24 +0000311 SmallVectorImpl<Decl *>::iterator DIt = Decls.begin();
312 for (SmallVectorImpl<Decl *>::iterator DE = Decls.end(); DIt != DE; ++DIt) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000313 Decl *D = *DIt;
314 if (D->getSourceRange().isInvalid())
315 continue;
316
317 if (isInLexicalContext(D, CurDC))
318 continue;
319
320 CurDC = dyn_cast<DeclContext>(D);
321
322 if (TagDecl *TD = dyn_cast<TagDecl>(D))
323 if (!TD->isFreeStanding())
324 continue;
325
326 RangeComparisonResult CompRes = RangeCompare(SM, D->getSourceRange(),Range);
327 if (CompRes == RangeBefore)
328 continue;
329 if (CompRes == RangeAfter)
330 break;
331
332 assert(CompRes == RangeOverlap);
333 VisitedAtLeastOnce = true;
334
335 if (isa<ObjCContainerDecl>(D)) {
336 FileDI_current = &DIt;
337 FileDE_current = DE;
338 } else {
339 FileDI_current = 0;
340 }
341
342 if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true))
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000343 return true; // visitation break.
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000344 }
345
346 if (VisitedAtLeastOnce)
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000347 return false;
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000348
349 // No Decls overlapped with the range. Move up the lexical context until there
350 // is a context that contains the range or we reach the translation unit
351 // level.
352 DeclContext *DC = DIt == Decls.begin() ? (*DIt)->getLexicalDeclContext()
353 : (*(DIt-1))->getLexicalDeclContext();
354
355 while (DC && !DC->isTranslationUnit()) {
356 Decl *D = cast<Decl>(DC);
357 SourceRange CurDeclRange = D->getSourceRange();
358 if (CurDeclRange.isInvalid())
359 break;
360
361 if (RangeCompare(SM, CurDeclRange, Range) == RangeOverlap) {
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000362 if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true))
363 return true; // visitation break.
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000364 }
365
366 DC = D->getLexicalDeclContext();
367 }
Argyrios Kyrtzidis389dc562013-03-08 20:42:33 +0000368
369 return false;
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000370}
371
372bool CursorVisitor::visitPreprocessedEntitiesInRegion() {
373 if (!AU->getPreprocessor().getPreprocessingRecord())
374 return false;
375
376 PreprocessingRecord &PPRec
377 = *AU->getPreprocessor().getPreprocessingRecord();
378 SourceManager &SM = AU->getSourceManager();
379
380 if (RegionOfInterest.isValid()) {
381 SourceRange MappedRange = AU->mapRangeToPreamble(RegionOfInterest);
382 SourceLocation B = MappedRange.getBegin();
383 SourceLocation E = MappedRange.getEnd();
384
385 if (AU->isInPreambleFileID(B)) {
386 if (SM.isLoadedSourceLocation(E))
387 return visitPreprocessedEntitiesInRange(SourceRange(B, E),
388 PPRec, *this);
389
390 // Beginning of range lies in the preamble but it also extends beyond
391 // it into the main file. Split the range into 2 parts, one covering
392 // the preamble and another covering the main file. This allows subsequent
393 // calls to visitPreprocessedEntitiesInRange to accept a source range that
394 // lies in the same FileID, allowing it to skip preprocessed entities that
395 // do not come from the same FileID.
396 bool breaked =
397 visitPreprocessedEntitiesInRange(
398 SourceRange(B, AU->getEndOfPreambleFileID()),
399 PPRec, *this);
400 if (breaked) return true;
401 return visitPreprocessedEntitiesInRange(
402 SourceRange(AU->getStartOfMainFileID(), E),
403 PPRec, *this);
404 }
405
406 return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec, *this);
407 }
408
409 bool OnlyLocalDecls
410 = !AU->isMainFileAST() && AU->getOnlyLocalDecls();
411
412 if (OnlyLocalDecls)
413 return visitPreprocessedEntities(PPRec.local_begin(), PPRec.local_end(),
414 PPRec);
415
416 return visitPreprocessedEntities(PPRec.begin(), PPRec.end(), PPRec);
417}
418
419template<typename InputIterator>
420bool CursorVisitor::visitPreprocessedEntities(InputIterator First,
421 InputIterator Last,
422 PreprocessingRecord &PPRec,
423 FileID FID) {
424 for (; First != Last; ++First) {
425 if (!FID.isInvalid() && !PPRec.isEntityInFileID(First, FID))
426 continue;
427
428 PreprocessedEntity *PPE = *First;
Argyrios Kyrtzidis333e44c2013-05-07 20:37:17 +0000429 if (!PPE)
430 continue;
431
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000432 if (MacroExpansion *ME = dyn_cast<MacroExpansion>(PPE)) {
433 if (Visit(MakeMacroExpansionCursor(ME, TU)))
434 return true;
435
436 continue;
437 }
438
439 if (MacroDefinition *MD = dyn_cast<MacroDefinition>(PPE)) {
440 if (Visit(MakeMacroDefinitionCursor(MD, TU)))
441 return true;
442
443 continue;
444 }
445
446 if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) {
447 if (Visit(MakeInclusionDirectiveCursor(ID, TU)))
448 return true;
449
450 continue;
451 }
452 }
453
454 return false;
455}
456
457/// \brief Visit the children of the given cursor.
458///
459/// \returns true if the visitation should be aborted, false if it
460/// should continue.
461bool CursorVisitor::VisitChildren(CXCursor Cursor) {
462 if (clang_isReference(Cursor.kind) &&
463 Cursor.kind != CXCursor_CXXBaseSpecifier) {
464 // By definition, references have no children.
465 return false;
466 }
467
468 // Set the Parent field to Cursor, then back to its old value once we're
469 // done.
470 SetParentRAII SetParent(Parent, StmtParent, Cursor);
471
472 if (clang_isDeclaration(Cursor.kind)) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +0000473 Decl *D = const_cast<Decl *>(getCursorDecl(Cursor));
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000474 if (!D)
475 return false;
476
477 return VisitAttributes(D) || Visit(D);
478 }
479
480 if (clang_isStatement(Cursor.kind)) {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +0000481 if (const Stmt *S = getCursorStmt(Cursor))
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000482 return Visit(S);
483
484 return false;
485 }
486
487 if (clang_isExpression(Cursor.kind)) {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +0000488 if (const Expr *E = getCursorExpr(Cursor))
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000489 return Visit(E);
490
491 return false;
492 }
493
494 if (clang_isTranslationUnit(Cursor.kind)) {
Dmitri Gribenko5694feb2013-01-26 18:53:38 +0000495 CXTranslationUnit TU = getCursorTU(Cursor);
496 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000497
498 int VisitOrder[2] = { VisitPreprocessorLast, !VisitPreprocessorLast };
499 for (unsigned I = 0; I != 2; ++I) {
500 if (VisitOrder[I]) {
501 if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() &&
502 RegionOfInterest.isInvalid()) {
503 for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(),
504 TLEnd = CXXUnit->top_level_end();
505 TL != TLEnd; ++TL) {
Dmitri Gribenko5694feb2013-01-26 18:53:38 +0000506 if (Visit(MakeCXCursor(*TL, TU, RegionOfInterest), true))
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000507 return true;
508 }
509 } else if (VisitDeclContext(
510 CXXUnit->getASTContext().getTranslationUnitDecl()))
511 return true;
512 continue;
513 }
514
515 // Walk the preprocessing record.
516 if (CXXUnit->getPreprocessor().getPreprocessingRecord())
517 visitPreprocessedEntitiesInRegion();
518 }
519
520 return false;
521 }
522
523 if (Cursor.kind == CXCursor_CXXBaseSpecifier) {
Dmitri Gribenko67812b22013-01-11 21:01:49 +0000524 if (const CXXBaseSpecifier *Base = getCursorCXXBaseSpecifier(Cursor)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000525 if (TypeSourceInfo *BaseTSInfo = Base->getTypeSourceInfo()) {
526 return Visit(BaseTSInfo->getTypeLoc());
527 }
528 }
529 }
530
531 if (Cursor.kind == CXCursor_IBOutletCollectionAttr) {
Dmitri Gribenko7d914382013-01-26 18:08:08 +0000532 const IBOutletCollectionAttr *A =
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000533 cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(Cursor));
534 if (const ObjCInterfaceType *InterT = A->getInterface()->getAs<ObjCInterfaceType>())
535 return Visit(cxcursor::MakeCursorObjCClassRef(InterT->getInterface(),
536 A->getInterfaceLoc(), TU));
537 }
538
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +0000539 // If pointing inside a macro definition, check if the token is an identifier
540 // that was ever defined as a macro. In such a case, create a "pseudo" macro
541 // expansion cursor for that token.
542 SourceLocation BeginLoc = RegionOfInterest.getBegin();
543 if (Cursor.kind == CXCursor_MacroDefinition &&
544 BeginLoc == RegionOfInterest.getEnd()) {
545 SourceLocation Loc = AU->mapLocationToPreamble(BeginLoc);
Dmitri Gribenko67812b22013-01-11 21:01:49 +0000546 const MacroInfo *MI =
547 getMacroInfo(cxcursor::getCursorMacroDefinition(Cursor), TU);
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +0000548 if (MacroDefinition *MacroDef =
549 checkForMacroInMacroDefinition(MI, Loc, TU))
550 return Visit(cxcursor::MakeMacroExpansionCursor(MacroDef, BeginLoc, TU));
551 }
552
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000553 // Nothing to visit at the moment.
554 return false;
555}
556
557bool CursorVisitor::VisitBlockDecl(BlockDecl *B) {
558 if (TypeSourceInfo *TSInfo = B->getSignatureAsWritten())
559 if (Visit(TSInfo->getTypeLoc()))
560 return true;
561
562 if (Stmt *Body = B->getBody())
563 return Visit(MakeCXCursor(Body, StmtParent, TU, RegionOfInterest));
564
565 return false;
566}
567
Ted Kremenek943f9092013-02-21 01:29:01 +0000568Optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000569 if (RegionOfInterest.isValid()) {
570 SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager());
571 if (Range.isInvalid())
David Blaikie66874fb2013-02-21 01:47:18 +0000572 return None;
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000573
574 switch (CompareRegionOfInterest(Range)) {
575 case RangeBefore:
576 // This declaration comes before the region of interest; skip it.
David Blaikie66874fb2013-02-21 01:47:18 +0000577 return None;
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000578
579 case RangeAfter:
580 // This declaration comes after the region of interest; we're done.
581 return false;
582
583 case RangeOverlap:
584 // This declaration overlaps the region of interest; visit it.
585 break;
586 }
587 }
588 return true;
589}
590
591bool CursorVisitor::VisitDeclContext(DeclContext *DC) {
592 DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end();
593
594 // FIXME: Eventually remove. This part of a hack to support proper
595 // iteration over all Decls contained lexically within an ObjC container.
596 SaveAndRestore<DeclContext::decl_iterator*> DI_saved(DI_current, &I);
597 SaveAndRestore<DeclContext::decl_iterator> DE_saved(DE_current, E);
598
599 for ( ; I != E; ++I) {
600 Decl *D = *I;
601 if (D->getLexicalDeclContext() != DC)
602 continue;
603 CXCursor Cursor = MakeCXCursor(D, TU, RegionOfInterest);
604
605 // Ignore synthesized ivars here, otherwise if we have something like:
606 // @synthesize prop = _prop;
607 // and '_prop' is not declared, we will encounter a '_prop' ivar before
608 // encountering the 'prop' synthesize declaration and we will think that
609 // we passed the region-of-interest.
610 if (ObjCIvarDecl *ivarD = dyn_cast<ObjCIvarDecl>(D)) {
611 if (ivarD->getSynthesize())
612 continue;
613 }
614
615 // FIXME: ObjCClassRef/ObjCProtocolRef for forward class/protocol
616 // declarations is a mismatch with the compiler semantics.
617 if (Cursor.kind == CXCursor_ObjCInterfaceDecl) {
618 ObjCInterfaceDecl *ID = cast<ObjCInterfaceDecl>(D);
619 if (!ID->isThisDeclarationADefinition())
620 Cursor = MakeCursorObjCClassRef(ID, ID->getLocation(), TU);
621
622 } else if (Cursor.kind == CXCursor_ObjCProtocolDecl) {
623 ObjCProtocolDecl *PD = cast<ObjCProtocolDecl>(D);
624 if (!PD->isThisDeclarationADefinition())
625 Cursor = MakeCursorObjCProtocolRef(PD, PD->getLocation(), TU);
626 }
627
Ted Kremenek943f9092013-02-21 01:29:01 +0000628 const Optional<bool> &V = shouldVisitCursor(Cursor);
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000629 if (!V.hasValue())
630 continue;
631 if (!V.getValue())
632 return false;
633 if (Visit(Cursor, true))
634 return true;
635 }
636 return false;
637}
638
639bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
640 llvm_unreachable("Translation units are visited directly by Visit()");
641}
642
643bool CursorVisitor::VisitTypeAliasDecl(TypeAliasDecl *D) {
644 if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())
645 return Visit(TSInfo->getTypeLoc());
646
647 return false;
648}
649
650bool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) {
651 if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())
652 return Visit(TSInfo->getTypeLoc());
653
654 return false;
655}
656
657bool CursorVisitor::VisitTagDecl(TagDecl *D) {
658 return VisitDeclContext(D);
659}
660
661bool CursorVisitor::VisitClassTemplateSpecializationDecl(
662 ClassTemplateSpecializationDecl *D) {
663 bool ShouldVisitBody = false;
664 switch (D->getSpecializationKind()) {
665 case TSK_Undeclared:
666 case TSK_ImplicitInstantiation:
667 // Nothing to visit
668 return false;
669
670 case TSK_ExplicitInstantiationDeclaration:
671 case TSK_ExplicitInstantiationDefinition:
672 break;
673
674 case TSK_ExplicitSpecialization:
675 ShouldVisitBody = true;
676 break;
677 }
678
679 // Visit the template arguments used in the specialization.
680 if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) {
681 TypeLoc TL = SpecType->getTypeLoc();
David Blaikie39e6ab42013-02-18 22:06:02 +0000682 if (TemplateSpecializationTypeLoc TSTLoc =
683 TL.getAs<TemplateSpecializationTypeLoc>()) {
684 for (unsigned I = 0, N = TSTLoc.getNumArgs(); I != N; ++I)
685 if (VisitTemplateArgumentLoc(TSTLoc.getArgLoc(I)))
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000686 return true;
687 }
688 }
689
690 if (ShouldVisitBody && VisitCXXRecordDecl(D))
691 return true;
692
693 return false;
694}
695
696bool CursorVisitor::VisitClassTemplatePartialSpecializationDecl(
697 ClassTemplatePartialSpecializationDecl *D) {
698 // FIXME: Visit the "outer" template parameter lists on the TagDecl
699 // before visiting these template parameters.
700 if (VisitTemplateParameters(D->getTemplateParameters()))
701 return true;
702
703 // Visit the partial specialization arguments.
704 const TemplateArgumentLoc *TemplateArgs = D->getTemplateArgsAsWritten();
705 for (unsigned I = 0, N = D->getNumTemplateArgsAsWritten(); I != N; ++I)
706 if (VisitTemplateArgumentLoc(TemplateArgs[I]))
707 return true;
708
709 return VisitCXXRecordDecl(D);
710}
711
712bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
713 // Visit the default argument.
714 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
715 if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo())
716 if (Visit(DefArg->getTypeLoc()))
717 return true;
718
719 return false;
720}
721
722bool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) {
723 if (Expr *Init = D->getInitExpr())
724 return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));
725 return false;
726}
727
728bool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) {
Argyrios Kyrtzidis516143b2013-04-05 21:04:10 +0000729 unsigned NumParamList = DD->getNumTemplateParameterLists();
730 for (unsigned i = 0; i < NumParamList; i++) {
731 TemplateParameterList* Params = DD->getTemplateParameterList(i);
732 if (VisitTemplateParameters(Params))
733 return true;
734 }
735
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000736 if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo())
737 if (Visit(TSInfo->getTypeLoc()))
738 return true;
739
740 // Visit the nested-name-specifier, if present.
741 if (NestedNameSpecifierLoc QualifierLoc = DD->getQualifierLoc())
742 if (VisitNestedNameSpecifierLoc(QualifierLoc))
743 return true;
744
745 return false;
746}
747
748/// \brief Compare two base or member initializers based on their source order.
749static int CompareCXXCtorInitializers(const void* Xp, const void *Yp) {
750 CXXCtorInitializer const * const *X
751 = static_cast<CXXCtorInitializer const * const *>(Xp);
752 CXXCtorInitializer const * const *Y
753 = static_cast<CXXCtorInitializer const * const *>(Yp);
754
755 if ((*X)->getSourceOrder() < (*Y)->getSourceOrder())
756 return -1;
757 else if ((*X)->getSourceOrder() > (*Y)->getSourceOrder())
758 return 1;
759 else
760 return 0;
761}
762
763bool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) {
Argyrios Kyrtzidis516143b2013-04-05 21:04:10 +0000764 unsigned NumParamList = ND->getNumTemplateParameterLists();
765 for (unsigned i = 0; i < NumParamList; i++) {
766 TemplateParameterList* Params = ND->getTemplateParameterList(i);
767 if (VisitTemplateParameters(Params))
768 return true;
769 }
770
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000771 if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) {
772 // Visit the function declaration's syntactic components in the order
773 // written. This requires a bit of work.
774 TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
David Blaikie39e6ab42013-02-18 22:06:02 +0000775 FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>();
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000776
777 // If we have a function declared directly (without the use of a typedef),
778 // visit just the return type. Otherwise, just visit the function's type
779 // now.
David Blaikie39e6ab42013-02-18 22:06:02 +0000780 if ((FTL && !isa<CXXConversionDecl>(ND) && Visit(FTL.getResultLoc())) ||
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000781 (!FTL && Visit(TL)))
782 return true;
783
784 // Visit the nested-name-specifier, if present.
785 if (NestedNameSpecifierLoc QualifierLoc = ND->getQualifierLoc())
786 if (VisitNestedNameSpecifierLoc(QualifierLoc))
787 return true;
788
789 // Visit the declaration name.
790 if (VisitDeclarationNameInfo(ND->getNameInfo()))
791 return true;
792
793 // FIXME: Visit explicitly-specified template arguments!
794
795 // Visit the function parameters, if we have a function type.
David Blaikie39e6ab42013-02-18 22:06:02 +0000796 if (FTL && VisitFunctionTypeLoc(FTL, true))
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000797 return true;
798
Bill Wendlingad017fa2012-12-20 19:22:21 +0000799 // FIXME: Attributes?
Guy Benyei7f92f2d2012-12-18 14:30:41 +0000800 }
801
802 if (ND->doesThisDeclarationHaveABody() && !ND->isLateTemplateParsed()) {
803 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) {
804 // Find the initializers that were written in the source.
805 SmallVector<CXXCtorInitializer *, 4> WrittenInits;
806 for (CXXConstructorDecl::init_iterator I = Constructor->init_begin(),
807 IEnd = Constructor->init_end();
808 I != IEnd; ++I) {
809 if (!(*I)->isWritten())
810 continue;
811
812 WrittenInits.push_back(*I);
813 }
814
815 // Sort the initializers in source order
816 llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(),
817 &CompareCXXCtorInitializers);
818
819 // Visit the initializers in source order
820 for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) {
821 CXXCtorInitializer *Init = WrittenInits[I];
822 if (Init->isAnyMemberInitializer()) {
823 if (Visit(MakeCursorMemberRef(Init->getAnyMember(),
824 Init->getMemberLocation(), TU)))
825 return true;
826 } else if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) {
827 if (Visit(TInfo->getTypeLoc()))
828 return true;
829 }
830
831 // Visit the initializer value.
832 if (Expr *Initializer = Init->getInit())
833 if (Visit(MakeCXCursor(Initializer, ND, TU, RegionOfInterest)))
834 return true;
835 }
836 }
837
838 if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest)))
839 return true;
840 }
841
842 return false;
843}
844
845bool CursorVisitor::VisitFieldDecl(FieldDecl *D) {
846 if (VisitDeclaratorDecl(D))
847 return true;
848
849 if (Expr *BitWidth = D->getBitWidth())
850 return Visit(MakeCXCursor(BitWidth, StmtParent, TU, RegionOfInterest));
851
852 return false;
853}
854
855bool CursorVisitor::VisitVarDecl(VarDecl *D) {
856 if (VisitDeclaratorDecl(D))
857 return true;
858
859 if (Expr *Init = D->getInit())
860 return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));
861
862 return false;
863}
864
865bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
866 if (VisitDeclaratorDecl(D))
867 return true;
868
869 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
870 if (Expr *DefArg = D->getDefaultArgument())
871 return Visit(MakeCXCursor(DefArg, StmtParent, TU, RegionOfInterest));
872
873 return false;
874}
875
876bool CursorVisitor::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
877 // FIXME: Visit the "outer" template parameter lists on the FunctionDecl
878 // before visiting these template parameters.
879 if (VisitTemplateParameters(D->getTemplateParameters()))
880 return true;
881
882 return VisitFunctionDecl(D->getTemplatedDecl());
883}
884
885bool CursorVisitor::VisitClassTemplateDecl(ClassTemplateDecl *D) {
886 // FIXME: Visit the "outer" template parameter lists on the TagDecl
887 // before visiting these template parameters.
888 if (VisitTemplateParameters(D->getTemplateParameters()))
889 return true;
890
891 return VisitCXXRecordDecl(D->getTemplatedDecl());
892}
893
894bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
895 if (VisitTemplateParameters(D->getTemplateParameters()))
896 return true;
897
898 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() &&
899 VisitTemplateArgumentLoc(D->getDefaultArgument()))
900 return true;
901
902 return false;
903}
904
905bool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) {
906 if (TypeSourceInfo *TSInfo = ND->getResultTypeSourceInfo())
907 if (Visit(TSInfo->getTypeLoc()))
908 return true;
909
910 for (ObjCMethodDecl::param_iterator P = ND->param_begin(),
911 PEnd = ND->param_end();
912 P != PEnd; ++P) {
913 if (Visit(MakeCXCursor(*P, TU, RegionOfInterest)))
914 return true;
915 }
916
917 if (ND->isThisDeclarationADefinition() &&
918 Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest)))
919 return true;
920
921 return false;
922}
923
924template <typename DeclIt>
925static void addRangedDeclsInContainer(DeclIt *DI_current, DeclIt DE_current,
926 SourceManager &SM, SourceLocation EndLoc,
927 SmallVectorImpl<Decl *> &Decls) {
928 DeclIt next = *DI_current;
929 while (++next != DE_current) {
930 Decl *D_next = *next;
931 if (!D_next)
932 break;
933 SourceLocation L = D_next->getLocStart();
934 if (!L.isValid())
935 break;
936 if (SM.isBeforeInTranslationUnit(L, EndLoc)) {
937 *DI_current = next;
938 Decls.push_back(D_next);
939 continue;
940 }
941 break;
942 }
943}
944
945namespace {
946 struct ContainerDeclsSort {
947 SourceManager &SM;
948 ContainerDeclsSort(SourceManager &sm) : SM(sm) {}
949 bool operator()(Decl *A, Decl *B) {
950 SourceLocation L_A = A->getLocStart();
951 SourceLocation L_B = B->getLocStart();
952 assert(L_A.isValid() && L_B.isValid());
953 return SM.isBeforeInTranslationUnit(L_A, L_B);
954 }
955 };
956}
957
958bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) {
959 // FIXME: Eventually convert back to just 'VisitDeclContext()'. Essentially
960 // an @implementation can lexically contain Decls that are not properly
961 // nested in the AST. When we identify such cases, we need to retrofit
962 // this nesting here.
963 if (!DI_current && !FileDI_current)
964 return VisitDeclContext(D);
965
966 // Scan the Decls that immediately come after the container
967 // in the current DeclContext. If any fall within the
968 // container's lexical region, stash them into a vector
969 // for later processing.
970 SmallVector<Decl *, 24> DeclsInContainer;
971 SourceLocation EndLoc = D->getSourceRange().getEnd();
972 SourceManager &SM = AU->getSourceManager();
973 if (EndLoc.isValid()) {
974 if (DI_current) {
975 addRangedDeclsInContainer(DI_current, DE_current, SM, EndLoc,
976 DeclsInContainer);
977 } else {
978 addRangedDeclsInContainer(FileDI_current, FileDE_current, SM, EndLoc,
979 DeclsInContainer);
980 }
981 }
982
983 // The common case.
984 if (DeclsInContainer.empty())
985 return VisitDeclContext(D);
986
987 // Get all the Decls in the DeclContext, and sort them with the
988 // additional ones we've collected. Then visit them.
989 for (DeclContext::decl_iterator I = D->decls_begin(), E = D->decls_end();
990 I!=E; ++I) {
991 Decl *subDecl = *I;
992 if (!subDecl || subDecl->getLexicalDeclContext() != D ||
993 subDecl->getLocStart().isInvalid())
994 continue;
995 DeclsInContainer.push_back(subDecl);
996 }
997
998 // Now sort the Decls so that they appear in lexical order.
999 std::sort(DeclsInContainer.begin(), DeclsInContainer.end(),
1000 ContainerDeclsSort(SM));
1001
1002 // Now visit the decls.
1003 for (SmallVectorImpl<Decl*>::iterator I = DeclsInContainer.begin(),
1004 E = DeclsInContainer.end(); I != E; ++I) {
1005 CXCursor Cursor = MakeCXCursor(*I, TU, RegionOfInterest);
Ted Kremenek943f9092013-02-21 01:29:01 +00001006 const Optional<bool> &V = shouldVisitCursor(Cursor);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001007 if (!V.hasValue())
1008 continue;
1009 if (!V.getValue())
1010 return false;
1011 if (Visit(Cursor, true))
1012 return true;
1013 }
1014 return false;
1015}
1016
1017bool CursorVisitor::VisitObjCCategoryDecl(ObjCCategoryDecl *ND) {
1018 if (Visit(MakeCursorObjCClassRef(ND->getClassInterface(), ND->getLocation(),
1019 TU)))
1020 return true;
1021
1022 ObjCCategoryDecl::protocol_loc_iterator PL = ND->protocol_loc_begin();
1023 for (ObjCCategoryDecl::protocol_iterator I = ND->protocol_begin(),
1024 E = ND->protocol_end(); I != E; ++I, ++PL)
1025 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1026 return true;
1027
1028 return VisitObjCContainerDecl(ND);
1029}
1030
1031bool CursorVisitor::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) {
1032 if (!PID->isThisDeclarationADefinition())
1033 return Visit(MakeCursorObjCProtocolRef(PID, PID->getLocation(), TU));
1034
1035 ObjCProtocolDecl::protocol_loc_iterator PL = PID->protocol_loc_begin();
1036 for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(),
1037 E = PID->protocol_end(); I != E; ++I, ++PL)
1038 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1039 return true;
1040
1041 return VisitObjCContainerDecl(PID);
1042}
1043
1044bool CursorVisitor::VisitObjCPropertyDecl(ObjCPropertyDecl *PD) {
1045 if (PD->getTypeSourceInfo() && Visit(PD->getTypeSourceInfo()->getTypeLoc()))
1046 return true;
1047
1048 // FIXME: This implements a workaround with @property declarations also being
1049 // installed in the DeclContext for the @interface. Eventually this code
1050 // should be removed.
1051 ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(PD->getDeclContext());
1052 if (!CDecl || !CDecl->IsClassExtension())
1053 return false;
1054
1055 ObjCInterfaceDecl *ID = CDecl->getClassInterface();
1056 if (!ID)
1057 return false;
1058
1059 IdentifierInfo *PropertyId = PD->getIdentifier();
1060 ObjCPropertyDecl *prevDecl =
1061 ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(ID), PropertyId);
1062
1063 if (!prevDecl)
1064 return false;
1065
1066 // Visit synthesized methods since they will be skipped when visiting
1067 // the @interface.
1068 if (ObjCMethodDecl *MD = prevDecl->getGetterMethodDecl())
1069 if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl)
1070 if (Visit(MakeCXCursor(MD, TU, RegionOfInterest)))
1071 return true;
1072
1073 if (ObjCMethodDecl *MD = prevDecl->getSetterMethodDecl())
1074 if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl)
1075 if (Visit(MakeCXCursor(MD, TU, RegionOfInterest)))
1076 return true;
1077
1078 return false;
1079}
1080
1081bool CursorVisitor::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
1082 if (!D->isThisDeclarationADefinition()) {
1083 // Forward declaration is treated like a reference.
1084 return Visit(MakeCursorObjCClassRef(D, D->getLocation(), TU));
1085 }
1086
1087 // Issue callbacks for super class.
1088 if (D->getSuperClass() &&
1089 Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(),
1090 D->getSuperClassLoc(),
1091 TU)))
1092 return true;
1093
1094 ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin();
1095 for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(),
1096 E = D->protocol_end(); I != E; ++I, ++PL)
1097 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1098 return true;
1099
1100 return VisitObjCContainerDecl(D);
1101}
1102
1103bool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) {
1104 return VisitObjCContainerDecl(D);
1105}
1106
1107bool CursorVisitor::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
1108 // 'ID' could be null when dealing with invalid code.
1109 if (ObjCInterfaceDecl *ID = D->getClassInterface())
1110 if (Visit(MakeCursorObjCClassRef(ID, D->getLocation(), TU)))
1111 return true;
1112
1113 return VisitObjCImplDecl(D);
1114}
1115
1116bool CursorVisitor::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
1117#if 0
1118 // Issue callbacks for super class.
1119 // FIXME: No source location information!
1120 if (D->getSuperClass() &&
1121 Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(),
1122 D->getSuperClassLoc(),
1123 TU)))
1124 return true;
1125#endif
1126
1127 return VisitObjCImplDecl(D);
1128}
1129
1130bool CursorVisitor::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD) {
1131 if (ObjCIvarDecl *Ivar = PD->getPropertyIvarDecl())
1132 if (PD->isIvarNameSpecified())
1133 return Visit(MakeCursorMemberRef(Ivar, PD->getPropertyIvarDeclLoc(), TU));
1134
1135 return false;
1136}
1137
1138bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) {
1139 return VisitDeclContext(D);
1140}
1141
1142bool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1143 // Visit nested-name-specifier.
1144 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1145 if (VisitNestedNameSpecifierLoc(QualifierLoc))
1146 return true;
1147
1148 return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(),
1149 D->getTargetNameLoc(), TU));
1150}
1151
1152bool CursorVisitor::VisitUsingDecl(UsingDecl *D) {
1153 // Visit nested-name-specifier.
1154 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
1155 if (VisitNestedNameSpecifierLoc(QualifierLoc))
1156 return true;
1157 }
1158
1159 if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU)))
1160 return true;
1161
1162 return VisitDeclarationNameInfo(D->getNameInfo());
1163}
1164
1165bool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1166 // Visit nested-name-specifier.
1167 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1168 if (VisitNestedNameSpecifierLoc(QualifierLoc))
1169 return true;
1170
1171 return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(),
1172 D->getIdentLocation(), TU));
1173}
1174
1175bool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1176 // Visit nested-name-specifier.
1177 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
1178 if (VisitNestedNameSpecifierLoc(QualifierLoc))
1179 return true;
1180 }
1181
1182 return VisitDeclarationNameInfo(D->getNameInfo());
1183}
1184
1185bool CursorVisitor::VisitUnresolvedUsingTypenameDecl(
1186 UnresolvedUsingTypenameDecl *D) {
1187 // Visit nested-name-specifier.
1188 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1189 if (VisitNestedNameSpecifierLoc(QualifierLoc))
1190 return true;
1191
1192 return false;
1193}
1194
1195bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) {
1196 switch (Name.getName().getNameKind()) {
1197 case clang::DeclarationName::Identifier:
1198 case clang::DeclarationName::CXXLiteralOperatorName:
1199 case clang::DeclarationName::CXXOperatorName:
1200 case clang::DeclarationName::CXXUsingDirective:
1201 return false;
1202
1203 case clang::DeclarationName::CXXConstructorName:
1204 case clang::DeclarationName::CXXDestructorName:
1205 case clang::DeclarationName::CXXConversionFunctionName:
1206 if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo())
1207 return Visit(TSInfo->getTypeLoc());
1208 return false;
1209
1210 case clang::DeclarationName::ObjCZeroArgSelector:
1211 case clang::DeclarationName::ObjCOneArgSelector:
1212 case clang::DeclarationName::ObjCMultiArgSelector:
1213 // FIXME: Per-identifier location info?
1214 return false;
1215 }
1216
1217 llvm_unreachable("Invalid DeclarationName::Kind!");
1218}
1219
1220bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS,
1221 SourceRange Range) {
1222 // FIXME: This whole routine is a hack to work around the lack of proper
1223 // source information in nested-name-specifiers (PR5791). Since we do have
1224 // a beginning source location, we can visit the first component of the
1225 // nested-name-specifier, if it's a single-token component.
1226 if (!NNS)
1227 return false;
1228
1229 // Get the first component in the nested-name-specifier.
1230 while (NestedNameSpecifier *Prefix = NNS->getPrefix())
1231 NNS = Prefix;
1232
1233 switch (NNS->getKind()) {
1234 case NestedNameSpecifier::Namespace:
1235 return Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(),
1236 TU));
1237
1238 case NestedNameSpecifier::NamespaceAlias:
1239 return Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(),
1240 Range.getBegin(), TU));
1241
1242 case NestedNameSpecifier::TypeSpec: {
1243 // If the type has a form where we know that the beginning of the source
1244 // range matches up with a reference cursor. Visit the appropriate reference
1245 // cursor.
1246 const Type *T = NNS->getAsType();
1247 if (const TypedefType *Typedef = dyn_cast<TypedefType>(T))
1248 return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU));
1249 if (const TagType *Tag = dyn_cast<TagType>(T))
1250 return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU));
1251 if (const TemplateSpecializationType *TST
1252 = dyn_cast<TemplateSpecializationType>(T))
1253 return VisitTemplateName(TST->getTemplateName(), Range.getBegin());
1254 break;
1255 }
1256
1257 case NestedNameSpecifier::TypeSpecWithTemplate:
1258 case NestedNameSpecifier::Global:
1259 case NestedNameSpecifier::Identifier:
1260 break;
1261 }
1262
1263 return false;
1264}
1265
1266bool
1267CursorVisitor::VisitNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) {
1268 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
1269 for (; Qualifier; Qualifier = Qualifier.getPrefix())
1270 Qualifiers.push_back(Qualifier);
1271
1272 while (!Qualifiers.empty()) {
1273 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
1274 NestedNameSpecifier *NNS = Q.getNestedNameSpecifier();
1275 switch (NNS->getKind()) {
1276 case NestedNameSpecifier::Namespace:
1277 if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(),
1278 Q.getLocalBeginLoc(),
1279 TU)))
1280 return true;
1281
1282 break;
1283
1284 case NestedNameSpecifier::NamespaceAlias:
1285 if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(),
1286 Q.getLocalBeginLoc(),
1287 TU)))
1288 return true;
1289
1290 break;
1291
1292 case NestedNameSpecifier::TypeSpec:
1293 case NestedNameSpecifier::TypeSpecWithTemplate:
1294 if (Visit(Q.getTypeLoc()))
1295 return true;
1296
1297 break;
1298
1299 case NestedNameSpecifier::Global:
1300 case NestedNameSpecifier::Identifier:
1301 break;
1302 }
1303 }
1304
1305 return false;
1306}
1307
1308bool CursorVisitor::VisitTemplateParameters(
1309 const TemplateParameterList *Params) {
1310 if (!Params)
1311 return false;
1312
1313 for (TemplateParameterList::const_iterator P = Params->begin(),
1314 PEnd = Params->end();
1315 P != PEnd; ++P) {
1316 if (Visit(MakeCXCursor(*P, TU, RegionOfInterest)))
1317 return true;
1318 }
1319
1320 return false;
1321}
1322
1323bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) {
1324 switch (Name.getKind()) {
1325 case TemplateName::Template:
1326 return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU));
1327
1328 case TemplateName::OverloadedTemplate:
1329 // Visit the overloaded template set.
1330 if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU)))
1331 return true;
1332
1333 return false;
1334
1335 case TemplateName::DependentTemplate:
1336 // FIXME: Visit nested-name-specifier.
1337 return false;
1338
1339 case TemplateName::QualifiedTemplate:
1340 // FIXME: Visit nested-name-specifier.
1341 return Visit(MakeCursorTemplateRef(
1342 Name.getAsQualifiedTemplateName()->getDecl(),
1343 Loc, TU));
1344
1345 case TemplateName::SubstTemplateTemplateParm:
1346 return Visit(MakeCursorTemplateRef(
1347 Name.getAsSubstTemplateTemplateParm()->getParameter(),
1348 Loc, TU));
1349
1350 case TemplateName::SubstTemplateTemplateParmPack:
1351 return Visit(MakeCursorTemplateRef(
1352 Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(),
1353 Loc, TU));
1354 }
1355
1356 llvm_unreachable("Invalid TemplateName::Kind!");
1357}
1358
1359bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) {
1360 switch (TAL.getArgument().getKind()) {
1361 case TemplateArgument::Null:
1362 case TemplateArgument::Integral:
1363 case TemplateArgument::Pack:
1364 return false;
1365
1366 case TemplateArgument::Type:
1367 if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo())
1368 return Visit(TSInfo->getTypeLoc());
1369 return false;
1370
1371 case TemplateArgument::Declaration:
1372 if (Expr *E = TAL.getSourceDeclExpression())
1373 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1374 return false;
1375
1376 case TemplateArgument::NullPtr:
1377 if (Expr *E = TAL.getSourceNullPtrExpression())
1378 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1379 return false;
1380
1381 case TemplateArgument::Expression:
1382 if (Expr *E = TAL.getSourceExpression())
1383 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1384 return false;
1385
1386 case TemplateArgument::Template:
1387 case TemplateArgument::TemplateExpansion:
1388 if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc()))
1389 return true;
1390
1391 return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(),
1392 TAL.getTemplateNameLoc());
1393 }
1394
1395 llvm_unreachable("Invalid TemplateArgument::Kind!");
1396}
1397
1398bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1399 return VisitDeclContext(D);
1400}
1401
1402bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
1403 return Visit(TL.getUnqualifiedLoc());
1404}
1405
1406bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
1407 ASTContext &Context = AU->getASTContext();
1408
1409 // Some builtin types (such as Objective-C's "id", "sel", and
1410 // "Class") have associated declarations. Create cursors for those.
1411 QualType VisitType;
1412 switch (TL.getTypePtr()->getKind()) {
1413
1414 case BuiltinType::Void:
1415 case BuiltinType::NullPtr:
1416 case BuiltinType::Dependent:
Guy Benyeib13621d2012-12-18 14:38:23 +00001417 case BuiltinType::OCLImage1d:
1418 case BuiltinType::OCLImage1dArray:
1419 case BuiltinType::OCLImage1dBuffer:
1420 case BuiltinType::OCLImage2d:
1421 case BuiltinType::OCLImage2dArray:
1422 case BuiltinType::OCLImage3d:
NAKAMURA Takumi775bb8a2013-02-07 12:47:42 +00001423 case BuiltinType::OCLSampler:
Guy Benyeie6b9d802013-01-20 12:31:11 +00001424 case BuiltinType::OCLEvent:
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001425#define BUILTIN_TYPE(Id, SingletonId)
1426#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1427#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1428#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
1429#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
1430#include "clang/AST/BuiltinTypes.def"
1431 break;
1432
1433 case BuiltinType::ObjCId:
1434 VisitType = Context.getObjCIdType();
1435 break;
1436
1437 case BuiltinType::ObjCClass:
1438 VisitType = Context.getObjCClassType();
1439 break;
1440
1441 case BuiltinType::ObjCSel:
1442 VisitType = Context.getObjCSelType();
1443 break;
1444 }
1445
1446 if (!VisitType.isNull()) {
1447 if (const TypedefType *Typedef = VisitType->getAs<TypedefType>())
1448 return Visit(MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(),
1449 TU));
1450 }
1451
1452 return false;
1453}
1454
1455bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
1456 return Visit(MakeCursorTypeRef(TL.getTypedefNameDecl(), TL.getNameLoc(), TU));
1457}
1458
1459bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
1460 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1461}
1462
1463bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) {
1464 if (TL.isDefinition())
1465 return Visit(MakeCXCursor(TL.getDecl(), TU, RegionOfInterest));
1466
1467 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1468}
1469
1470bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
1471 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1472}
1473
1474bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
1475 if (Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU)))
1476 return true;
1477
1478 return false;
1479}
1480
1481bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
1482 if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc()))
1483 return true;
1484
1485 for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
1486 if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I),
1487 TU)))
1488 return true;
1489 }
1490
1491 return false;
1492}
1493
1494bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
1495 return Visit(TL.getPointeeLoc());
1496}
1497
1498bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) {
1499 return Visit(TL.getInnerLoc());
1500}
1501
1502bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) {
1503 return Visit(TL.getPointeeLoc());
1504}
1505
1506bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
1507 return Visit(TL.getPointeeLoc());
1508}
1509
1510bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
1511 return Visit(TL.getPointeeLoc());
1512}
1513
1514bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
1515 return Visit(TL.getPointeeLoc());
1516}
1517
1518bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
1519 return Visit(TL.getPointeeLoc());
1520}
1521
1522bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
1523 return Visit(TL.getModifiedLoc());
1524}
1525
1526bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL,
1527 bool SkipResultType) {
1528 if (!SkipResultType && Visit(TL.getResultLoc()))
1529 return true;
1530
1531 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1532 if (Decl *D = TL.getArg(I))
1533 if (Visit(MakeCXCursor(D, TU, RegionOfInterest)))
1534 return true;
1535
1536 return false;
1537}
1538
1539bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) {
1540 if (Visit(TL.getElementLoc()))
1541 return true;
1542
1543 if (Expr *Size = TL.getSizeExpr())
1544 return Visit(MakeCXCursor(Size, StmtParent, TU, RegionOfInterest));
1545
1546 return false;
1547}
1548
Reid Kleckner12df2462013-06-24 17:51:48 +00001549bool CursorVisitor::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
1550 return Visit(TL.getOriginalLoc());
1551}
1552
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001553bool CursorVisitor::VisitTemplateSpecializationTypeLoc(
1554 TemplateSpecializationTypeLoc TL) {
1555 // Visit the template name.
1556 if (VisitTemplateName(TL.getTypePtr()->getTemplateName(),
1557 TL.getTemplateNameLoc()))
1558 return true;
1559
1560 // Visit the template arguments.
1561 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1562 if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
1563 return true;
1564
1565 return false;
1566}
1567
1568bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
1569 return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU));
1570}
1571
1572bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
1573 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
1574 return Visit(TSInfo->getTypeLoc());
1575
1576 return false;
1577}
1578
1579bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
1580 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
1581 return Visit(TSInfo->getTypeLoc());
1582
1583 return false;
1584}
1585
1586bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
1587 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1588 return true;
1589
1590 return false;
1591}
1592
1593bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc(
1594 DependentTemplateSpecializationTypeLoc TL) {
1595 // Visit the nested-name-specifier, if there is one.
1596 if (TL.getQualifierLoc() &&
1597 VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1598 return true;
1599
1600 // Visit the template arguments.
1601 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1602 if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
1603 return true;
1604
1605 return false;
1606}
1607
1608bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
1609 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1610 return true;
1611
1612 return Visit(TL.getNamedTypeLoc());
1613}
1614
1615bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
1616 return Visit(TL.getPatternLoc());
1617}
1618
1619bool CursorVisitor::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
1620 if (Expr *E = TL.getUnderlyingExpr())
1621 return Visit(MakeCXCursor(E, StmtParent, TU));
1622
1623 return false;
1624}
1625
1626bool CursorVisitor::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
1627 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1628}
1629
1630bool CursorVisitor::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
1631 return Visit(TL.getValueLoc());
1632}
1633
1634#define DEFAULT_TYPELOC_IMPL(CLASS, PARENT) \
1635bool CursorVisitor::Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { \
1636 return Visit##PARENT##Loc(TL); \
1637}
1638
1639DEFAULT_TYPELOC_IMPL(Complex, Type)
1640DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType)
1641DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType)
1642DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType)
1643DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType)
1644DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type)
1645DEFAULT_TYPELOC_IMPL(Vector, Type)
1646DEFAULT_TYPELOC_IMPL(ExtVector, VectorType)
1647DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType)
1648DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType)
1649DEFAULT_TYPELOC_IMPL(Record, TagType)
1650DEFAULT_TYPELOC_IMPL(Enum, TagType)
1651DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type)
1652DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type)
1653DEFAULT_TYPELOC_IMPL(Auto, Type)
1654
1655bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) {
1656 // Visit the nested-name-specifier, if present.
1657 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1658 if (VisitNestedNameSpecifierLoc(QualifierLoc))
1659 return true;
1660
1661 if (D->isCompleteDefinition()) {
1662 for (CXXRecordDecl::base_class_iterator I = D->bases_begin(),
1663 E = D->bases_end(); I != E; ++I) {
1664 if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(I, TU)))
1665 return true;
1666 }
1667 }
1668
1669 return VisitTagDecl(D);
1670}
1671
1672bool CursorVisitor::VisitAttributes(Decl *D) {
1673 for (AttrVec::const_iterator i = D->attr_begin(), e = D->attr_end();
1674 i != e; ++i)
1675 if (Visit(MakeCXCursor(*i, D, TU)))
1676 return true;
1677
1678 return false;
1679}
1680
1681//===----------------------------------------------------------------------===//
1682// Data-recursive visitor methods.
1683//===----------------------------------------------------------------------===//
1684
1685namespace {
1686#define DEF_JOB(NAME, DATA, KIND)\
1687class NAME : public VisitorJob {\
1688public:\
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001689 NAME(const DATA *d, CXCursor parent) : \
1690 VisitorJob(parent, VisitorJob::KIND, d) {} \
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001691 static bool classof(const VisitorJob *VJ) { return VJ->getKind() == KIND; }\
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001692 const DATA *get() const { return static_cast<const DATA*>(data[0]); }\
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001693};
1694
1695DEF_JOB(StmtVisit, Stmt, StmtVisitKind)
1696DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind)
1697DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind)
1698DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind)
1699DEF_JOB(ExplicitTemplateArgsVisit, ASTTemplateArgumentListInfo,
1700 ExplicitTemplateArgsVisitKind)
1701DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind)
1702DEF_JOB(LambdaExprParts, LambdaExpr, LambdaExprPartsKind)
1703DEF_JOB(PostChildrenVisit, void, PostChildrenVisitKind)
1704#undef DEF_JOB
1705
1706class DeclVisit : public VisitorJob {
1707public:
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001708 DeclVisit(const Decl *D, CXCursor parent, bool isFirst) :
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001709 VisitorJob(parent, VisitorJob::DeclVisitKind,
Dmitri Gribenkoa376f872013-02-03 13:19:54 +00001710 D, isFirst ? (void*) 1 : (void*) 0) {}
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001711 static bool classof(const VisitorJob *VJ) {
1712 return VJ->getKind() == DeclVisitKind;
1713 }
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001714 const Decl *get() const { return static_cast<const Decl *>(data[0]); }
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001715 bool isFirst() const { return data[1] ? true : false; }
1716};
1717class TypeLocVisit : public VisitorJob {
1718public:
1719 TypeLocVisit(TypeLoc tl, CXCursor parent) :
1720 VisitorJob(parent, VisitorJob::TypeLocVisitKind,
1721 tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {}
1722
1723 static bool classof(const VisitorJob *VJ) {
1724 return VJ->getKind() == TypeLocVisitKind;
1725 }
1726
1727 TypeLoc get() const {
1728 QualType T = QualType::getFromOpaquePtr(data[0]);
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001729 return TypeLoc(T, const_cast<void *>(data[1]));
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001730 }
1731};
1732
1733class LabelRefVisit : public VisitorJob {
1734public:
1735 LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent)
1736 : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD,
1737 labelLoc.getPtrEncoding()) {}
1738
1739 static bool classof(const VisitorJob *VJ) {
1740 return VJ->getKind() == VisitorJob::LabelRefVisitKind;
1741 }
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001742 const LabelDecl *get() const {
1743 return static_cast<const LabelDecl *>(data[0]);
1744 }
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001745 SourceLocation getLoc() const {
1746 return SourceLocation::getFromPtrEncoding(data[1]); }
1747};
1748
1749class NestedNameSpecifierLocVisit : public VisitorJob {
1750public:
1751 NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent)
1752 : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind,
1753 Qualifier.getNestedNameSpecifier(),
1754 Qualifier.getOpaqueData()) { }
1755
1756 static bool classof(const VisitorJob *VJ) {
1757 return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind;
1758 }
1759
1760 NestedNameSpecifierLoc get() const {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001761 return NestedNameSpecifierLoc(
1762 const_cast<NestedNameSpecifier *>(
1763 static_cast<const NestedNameSpecifier *>(data[0])),
1764 const_cast<void *>(data[1]));
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001765 }
1766};
1767
1768class DeclarationNameInfoVisit : public VisitorJob {
1769public:
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001770 DeclarationNameInfoVisit(const Stmt *S, CXCursor parent)
Dmitri Gribenkoa376f872013-02-03 13:19:54 +00001771 : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {}
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001772 static bool classof(const VisitorJob *VJ) {
1773 return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind;
1774 }
1775 DeclarationNameInfo get() const {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001776 const Stmt *S = static_cast<const Stmt *>(data[0]);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001777 switch (S->getStmtClass()) {
1778 default:
1779 llvm_unreachable("Unhandled Stmt");
1780 case clang::Stmt::MSDependentExistsStmtClass:
1781 return cast<MSDependentExistsStmt>(S)->getNameInfo();
1782 case Stmt::CXXDependentScopeMemberExprClass:
1783 return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo();
1784 case Stmt::DependentScopeDeclRefExprClass:
1785 return cast<DependentScopeDeclRefExpr>(S)->getNameInfo();
1786 }
1787 }
1788};
1789class MemberRefVisit : public VisitorJob {
1790public:
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001791 MemberRefVisit(const FieldDecl *D, SourceLocation L, CXCursor parent)
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001792 : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D,
1793 L.getPtrEncoding()) {}
1794 static bool classof(const VisitorJob *VJ) {
1795 return VJ->getKind() == VisitorJob::MemberRefVisitKind;
1796 }
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001797 const FieldDecl *get() const {
1798 return static_cast<const FieldDecl *>(data[0]);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001799 }
1800 SourceLocation getLoc() const {
1801 return SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[1]);
1802 }
1803};
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001804class EnqueueVisitor : public ConstStmtVisitor<EnqueueVisitor, void> {
Alexey Bataev4fa7eab2013-07-19 03:13:43 +00001805 friend class OMPClauseEnqueue;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001806 VisitorWorkList &WL;
1807 CXCursor Parent;
1808public:
1809 EnqueueVisitor(VisitorWorkList &wl, CXCursor parent)
1810 : WL(wl), Parent(parent) {}
1811
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001812 void VisitAddrLabelExpr(const AddrLabelExpr *E);
1813 void VisitBlockExpr(const BlockExpr *B);
1814 void VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
1815 void VisitCompoundStmt(const CompoundStmt *S);
1816 void VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) { /* Do nothing. */ }
1817 void VisitMSDependentExistsStmt(const MSDependentExistsStmt *S);
1818 void VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E);
1819 void VisitCXXNewExpr(const CXXNewExpr *E);
1820 void VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E);
1821 void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *E);
1822 void VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E);
1823 void VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E);
1824 void VisitCXXTypeidExpr(const CXXTypeidExpr *E);
1825 void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *E);
1826 void VisitCXXUuidofExpr(const CXXUuidofExpr *E);
1827 void VisitCXXCatchStmt(const CXXCatchStmt *S);
1828 void VisitDeclRefExpr(const DeclRefExpr *D);
1829 void VisitDeclStmt(const DeclStmt *S);
1830 void VisitDependentScopeDeclRefExpr(const DependentScopeDeclRefExpr *E);
1831 void VisitDesignatedInitExpr(const DesignatedInitExpr *E);
1832 void VisitExplicitCastExpr(const ExplicitCastExpr *E);
1833 void VisitForStmt(const ForStmt *FS);
1834 void VisitGotoStmt(const GotoStmt *GS);
1835 void VisitIfStmt(const IfStmt *If);
1836 void VisitInitListExpr(const InitListExpr *IE);
1837 void VisitMemberExpr(const MemberExpr *M);
1838 void VisitOffsetOfExpr(const OffsetOfExpr *E);
1839 void VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
1840 void VisitObjCMessageExpr(const ObjCMessageExpr *M);
1841 void VisitOverloadExpr(const OverloadExpr *E);
1842 void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
1843 void VisitStmt(const Stmt *S);
1844 void VisitSwitchStmt(const SwitchStmt *S);
1845 void VisitWhileStmt(const WhileStmt *W);
1846 void VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E);
1847 void VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *E);
1848 void VisitTypeTraitExpr(const TypeTraitExpr *E);
1849 void VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E);
1850 void VisitExpressionTraitExpr(const ExpressionTraitExpr *E);
1851 void VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U);
1852 void VisitVAArgExpr(const VAArgExpr *E);
1853 void VisitSizeOfPackExpr(const SizeOfPackExpr *E);
1854 void VisitPseudoObjectExpr(const PseudoObjectExpr *E);
1855 void VisitOpaqueValueExpr(const OpaqueValueExpr *E);
1856 void VisitLambdaExpr(const LambdaExpr *E);
Alexey Bataev4fa7eab2013-07-19 03:13:43 +00001857 void VisitOMPExecutableDirective(const OMPExecutableDirective *D);
1858 void VisitOMPParallelDirective(const OMPParallelDirective *D);
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001859
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001860private:
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001861 void AddDeclarationNameInfo(const Stmt *S);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001862 void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier);
1863 void AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A);
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001864 void AddMemberRef(const FieldDecl *D, SourceLocation L);
1865 void AddStmt(const Stmt *S);
1866 void AddDecl(const Decl *D, bool isFirst = true);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001867 void AddTypeLoc(TypeSourceInfo *TI);
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001868 void EnqueueChildren(const Stmt *S);
Alexey Bataev4fa7eab2013-07-19 03:13:43 +00001869 void EnqueueChildren(const OMPClause *S);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001870};
1871} // end anonyous namespace
1872
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001873void EnqueueVisitor::AddDeclarationNameInfo(const Stmt *S) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001874 // 'S' should always be non-null, since it comes from the
1875 // statement we are visiting.
1876 WL.push_back(DeclarationNameInfoVisit(S, Parent));
1877}
1878
1879void
1880EnqueueVisitor::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) {
1881 if (Qualifier)
1882 WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent));
1883}
1884
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001885void EnqueueVisitor::AddStmt(const Stmt *S) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001886 if (S)
1887 WL.push_back(StmtVisit(S, Parent));
1888}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001889void EnqueueVisitor::AddDecl(const Decl *D, bool isFirst) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001890 if (D)
1891 WL.push_back(DeclVisit(D, Parent, isFirst));
1892}
1893void EnqueueVisitor::
1894 AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A) {
1895 if (A)
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001896 WL.push_back(ExplicitTemplateArgsVisit(A, Parent));
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001897}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001898void EnqueueVisitor::AddMemberRef(const FieldDecl *D, SourceLocation L) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001899 if (D)
1900 WL.push_back(MemberRefVisit(D, L, Parent));
1901}
1902void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) {
1903 if (TI)
1904 WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent));
1905 }
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001906void EnqueueVisitor::EnqueueChildren(const Stmt *S) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001907 unsigned size = WL.size();
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001908 for (Stmt::const_child_range Child = S->children(); Child; ++Child) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001909 AddStmt(*Child);
1910 }
1911 if (size == WL.size())
1912 return;
1913 // Now reverse the entries we just added. This will match the DFS
1914 // ordering performed by the worklist.
1915 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
1916 std::reverse(I, E);
1917}
Alexey Bataev4fa7eab2013-07-19 03:13:43 +00001918namespace {
1919class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> {
1920 EnqueueVisitor *Visitor;
1921public:
1922 OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) { }
1923#define OPENMP_CLAUSE(Name, Class) \
1924 void Visit##Class(const Class *C);
1925#include "clang/Basic/OpenMPKinds.def"
1926};
1927
1928void OMPClauseEnqueue::VisitOMPDefaultClause(const OMPDefaultClause *C) { }
1929#define PROCESS_OMP_CLAUSE_LIST(Class, Node) \
1930 for (OMPVarList<Class>::varlist_const_iterator I = Node->varlist_begin(), \
1931 E = Node->varlist_end(); \
1932 I != E; ++I) \
1933 Visitor->AddStmt(*I);
1934
1935void OMPClauseEnqueue::VisitOMPPrivateClause(const OMPPrivateClause *C) {
1936 PROCESS_OMP_CLAUSE_LIST(OMPPrivateClause, C)
1937}
1938#undef PROCESS_OMP_CLAUSE_LIST
1939}
1940void EnqueueVisitor::EnqueueChildren(const OMPClause *S) {
1941 unsigned size = WL.size();
1942 OMPClauseEnqueue Visitor(this);
1943 Visitor.Visit(S);
1944 if (size == WL.size())
1945 return;
1946 // Now reverse the entries we just added. This will match the DFS
1947 // ordering performed by the worklist.
1948 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
1949 std::reverse(I, E);
1950}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001951void EnqueueVisitor::VisitAddrLabelExpr(const AddrLabelExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001952 WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent));
1953}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001954void EnqueueVisitor::VisitBlockExpr(const BlockExpr *B) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001955 AddDecl(B->getBlockDecl());
1956}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001957void EnqueueVisitor::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001958 EnqueueChildren(E);
1959 AddTypeLoc(E->getTypeSourceInfo());
1960}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001961void EnqueueVisitor::VisitCompoundStmt(const CompoundStmt *S) {
1962 for (CompoundStmt::const_reverse_body_iterator I = S->body_rbegin(),
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001963 E = S->body_rend(); I != E; ++I) {
1964 AddStmt(*I);
1965 }
1966}
1967void EnqueueVisitor::
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001968VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001969 AddStmt(S->getSubStmt());
1970 AddDeclarationNameInfo(S);
1971 if (NestedNameSpecifierLoc QualifierLoc = S->getQualifierLoc())
1972 AddNestedNameSpecifierLoc(QualifierLoc);
1973}
1974
1975void EnqueueVisitor::
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001976VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001977 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs());
1978 AddDeclarationNameInfo(E);
1979 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
1980 AddNestedNameSpecifierLoc(QualifierLoc);
1981 if (!E->isImplicitAccess())
1982 AddStmt(E->getBase());
1983}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001984void EnqueueVisitor::VisitCXXNewExpr(const CXXNewExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001985 // Enqueue the initializer , if any.
1986 AddStmt(E->getInitializer());
1987 // Enqueue the array size, if any.
1988 AddStmt(E->getArraySize());
1989 // Enqueue the allocated type.
1990 AddTypeLoc(E->getAllocatedTypeSourceInfo());
1991 // Enqueue the placement arguments.
1992 for (unsigned I = E->getNumPlacementArgs(); I > 0; --I)
1993 AddStmt(E->getPlacementArg(I-1));
1994}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00001995void EnqueueVisitor::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *CE) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00001996 for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I)
1997 AddStmt(CE->getArg(I-1));
1998 AddStmt(CE->getCallee());
1999 AddStmt(CE->getArg(0));
2000}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002001void EnqueueVisitor::VisitCXXPseudoDestructorExpr(
2002 const CXXPseudoDestructorExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002003 // Visit the name of the type being destroyed.
2004 AddTypeLoc(E->getDestroyedTypeInfo());
2005 // Visit the scope type that looks disturbingly like the nested-name-specifier
2006 // but isn't.
2007 AddTypeLoc(E->getScopeTypeInfo());
2008 // Visit the nested-name-specifier.
2009 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
2010 AddNestedNameSpecifierLoc(QualifierLoc);
2011 // Visit base expression.
2012 AddStmt(E->getBase());
2013}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002014void EnqueueVisitor::VisitCXXScalarValueInitExpr(
2015 const CXXScalarValueInitExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002016 AddTypeLoc(E->getTypeSourceInfo());
2017}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002018void EnqueueVisitor::VisitCXXTemporaryObjectExpr(
2019 const CXXTemporaryObjectExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002020 EnqueueChildren(E);
2021 AddTypeLoc(E->getTypeSourceInfo());
2022}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002023void EnqueueVisitor::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002024 EnqueueChildren(E);
2025 if (E->isTypeOperand())
2026 AddTypeLoc(E->getTypeOperandSourceInfo());
2027}
2028
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002029void EnqueueVisitor::VisitCXXUnresolvedConstructExpr(
2030 const CXXUnresolvedConstructExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002031 EnqueueChildren(E);
2032 AddTypeLoc(E->getTypeSourceInfo());
2033}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002034void EnqueueVisitor::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002035 EnqueueChildren(E);
2036 if (E->isTypeOperand())
2037 AddTypeLoc(E->getTypeOperandSourceInfo());
2038}
2039
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002040void EnqueueVisitor::VisitCXXCatchStmt(const CXXCatchStmt *S) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002041 EnqueueChildren(S);
2042 AddDecl(S->getExceptionDecl());
2043}
2044
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002045void EnqueueVisitor::VisitDeclRefExpr(const DeclRefExpr *DR) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002046 if (DR->hasExplicitTemplateArgs()) {
2047 AddExplicitTemplateArgs(&DR->getExplicitTemplateArgs());
2048 }
2049 WL.push_back(DeclRefExprParts(DR, Parent));
2050}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002051void EnqueueVisitor::VisitDependentScopeDeclRefExpr(
2052 const DependentScopeDeclRefExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002053 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs());
2054 AddDeclarationNameInfo(E);
2055 AddNestedNameSpecifierLoc(E->getQualifierLoc());
2056}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002057void EnqueueVisitor::VisitDeclStmt(const DeclStmt *S) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002058 unsigned size = WL.size();
2059 bool isFirst = true;
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002060 for (DeclStmt::const_decl_iterator D = S->decl_begin(), DEnd = S->decl_end();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002061 D != DEnd; ++D) {
2062 AddDecl(*D, isFirst);
2063 isFirst = false;
2064 }
2065 if (size == WL.size())
2066 return;
2067 // Now reverse the entries we just added. This will match the DFS
2068 // ordering performed by the worklist.
2069 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
2070 std::reverse(I, E);
2071}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002072void EnqueueVisitor::VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002073 AddStmt(E->getInit());
2074 typedef DesignatedInitExpr::Designator Designator;
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002075 for (DesignatedInitExpr::const_reverse_designators_iterator
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002076 D = E->designators_rbegin(), DEnd = E->designators_rend();
2077 D != DEnd; ++D) {
2078 if (D->isFieldDesignator()) {
2079 if (FieldDecl *Field = D->getField())
2080 AddMemberRef(Field, D->getFieldLoc());
2081 continue;
2082 }
2083 if (D->isArrayDesignator()) {
2084 AddStmt(E->getArrayIndex(*D));
2085 continue;
2086 }
2087 assert(D->isArrayRangeDesignator() && "Unknown designator kind");
2088 AddStmt(E->getArrayRangeEnd(*D));
2089 AddStmt(E->getArrayRangeStart(*D));
2090 }
2091}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002092void EnqueueVisitor::VisitExplicitCastExpr(const ExplicitCastExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002093 EnqueueChildren(E);
2094 AddTypeLoc(E->getTypeInfoAsWritten());
2095}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002096void EnqueueVisitor::VisitForStmt(const ForStmt *FS) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002097 AddStmt(FS->getBody());
2098 AddStmt(FS->getInc());
2099 AddStmt(FS->getCond());
2100 AddDecl(FS->getConditionVariable());
2101 AddStmt(FS->getInit());
2102}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002103void EnqueueVisitor::VisitGotoStmt(const GotoStmt *GS) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002104 WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent));
2105}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002106void EnqueueVisitor::VisitIfStmt(const IfStmt *If) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002107 AddStmt(If->getElse());
2108 AddStmt(If->getThen());
2109 AddStmt(If->getCond());
2110 AddDecl(If->getConditionVariable());
2111}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002112void EnqueueVisitor::VisitInitListExpr(const InitListExpr *IE) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002113 // We care about the syntactic form of the initializer list, only.
2114 if (InitListExpr *Syntactic = IE->getSyntacticForm())
2115 IE = Syntactic;
2116 EnqueueChildren(IE);
2117}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002118void EnqueueVisitor::VisitMemberExpr(const MemberExpr *M) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002119 WL.push_back(MemberExprParts(M, Parent));
2120
2121 // If the base of the member access expression is an implicit 'this', don't
2122 // visit it.
2123 // FIXME: If we ever want to show these implicit accesses, this will be
2124 // unfortunate. However, clang_getCursor() relies on this behavior.
2125 if (!M->isImplicitAccess())
2126 AddStmt(M->getBase());
2127}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002128void EnqueueVisitor::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002129 AddTypeLoc(E->getEncodedTypeSourceInfo());
2130}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002131void EnqueueVisitor::VisitObjCMessageExpr(const ObjCMessageExpr *M) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002132 EnqueueChildren(M);
2133 AddTypeLoc(M->getClassReceiverTypeInfo());
2134}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002135void EnqueueVisitor::VisitOffsetOfExpr(const OffsetOfExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002136 // Visit the components of the offsetof expression.
2137 for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) {
2138 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode;
2139 const OffsetOfNode &Node = E->getComponent(I-1);
2140 switch (Node.getKind()) {
2141 case OffsetOfNode::Array:
2142 AddStmt(E->getIndexExpr(Node.getArrayExprIndex()));
2143 break;
2144 case OffsetOfNode::Field:
2145 AddMemberRef(Node.getField(), Node.getSourceRange().getEnd());
2146 break;
2147 case OffsetOfNode::Identifier:
2148 case OffsetOfNode::Base:
2149 continue;
2150 }
2151 }
2152 // Visit the type into which we're computing the offset.
2153 AddTypeLoc(E->getTypeSourceInfo());
2154}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002155void EnqueueVisitor::VisitOverloadExpr(const OverloadExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002156 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs());
2157 WL.push_back(OverloadExprParts(E, Parent));
2158}
2159void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr(
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002160 const UnaryExprOrTypeTraitExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002161 EnqueueChildren(E);
2162 if (E->isArgumentType())
2163 AddTypeLoc(E->getArgumentTypeInfo());
2164}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002165void EnqueueVisitor::VisitStmt(const Stmt *S) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002166 EnqueueChildren(S);
2167}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002168void EnqueueVisitor::VisitSwitchStmt(const SwitchStmt *S) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002169 AddStmt(S->getBody());
2170 AddStmt(S->getCond());
2171 AddDecl(S->getConditionVariable());
2172}
2173
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002174void EnqueueVisitor::VisitWhileStmt(const WhileStmt *W) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002175 AddStmt(W->getBody());
2176 AddStmt(W->getCond());
2177 AddDecl(W->getConditionVariable());
2178}
2179
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002180void EnqueueVisitor::VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002181 AddTypeLoc(E->getQueriedTypeSourceInfo());
2182}
2183
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002184void EnqueueVisitor::VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002185 AddTypeLoc(E->getRhsTypeSourceInfo());
2186 AddTypeLoc(E->getLhsTypeSourceInfo());
2187}
2188
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002189void EnqueueVisitor::VisitTypeTraitExpr(const TypeTraitExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002190 for (unsigned I = E->getNumArgs(); I > 0; --I)
2191 AddTypeLoc(E->getArg(I-1));
2192}
2193
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002194void EnqueueVisitor::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002195 AddTypeLoc(E->getQueriedTypeSourceInfo());
2196}
2197
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002198void EnqueueVisitor::VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002199 EnqueueChildren(E);
2200}
2201
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002202void EnqueueVisitor::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002203 VisitOverloadExpr(U);
2204 if (!U->isImplicitAccess())
2205 AddStmt(U->getBase());
2206}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002207void EnqueueVisitor::VisitVAArgExpr(const VAArgExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002208 AddStmt(E->getSubExpr());
2209 AddTypeLoc(E->getWrittenTypeInfo());
2210}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002211void EnqueueVisitor::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002212 WL.push_back(SizeOfPackExprParts(E, Parent));
2213}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002214void EnqueueVisitor::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002215 // If the opaque value has a source expression, just transparently
2216 // visit that. This is useful for (e.g.) pseudo-object expressions.
2217 if (Expr *SourceExpr = E->getSourceExpr())
2218 return Visit(SourceExpr);
2219}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002220void EnqueueVisitor::VisitLambdaExpr(const LambdaExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002221 AddStmt(E->getBody());
2222 WL.push_back(LambdaExprParts(E, Parent));
2223}
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002224void EnqueueVisitor::VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002225 // Treat the expression like its syntactic form.
2226 Visit(E->getSyntacticForm());
2227}
2228
Alexey Bataev4fa7eab2013-07-19 03:13:43 +00002229void EnqueueVisitor::VisitOMPExecutableDirective(
2230 const OMPExecutableDirective *D) {
2231 EnqueueChildren(D);
2232 for (ArrayRef<OMPClause *>::iterator I = D->clauses().begin(),
2233 E = D->clauses().end();
2234 I != E; ++I)
2235 EnqueueChildren(*I);
2236}
2237
2238void EnqueueVisitor::VisitOMPParallelDirective(const OMPParallelDirective *D) {
2239 VisitOMPExecutableDirective(D);
2240}
2241
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002242void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002243 EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S);
2244}
2245
2246bool CursorVisitor::IsInRegionOfInterest(CXCursor C) {
2247 if (RegionOfInterest.isValid()) {
2248 SourceRange Range = getRawCursorExtent(C);
2249 if (Range.isInvalid() || CompareRegionOfInterest(Range))
2250 return false;
2251 }
2252 return true;
2253}
2254
2255bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) {
2256 while (!WL.empty()) {
2257 // Dequeue the worklist item.
2258 VisitorJob LI = WL.back();
2259 WL.pop_back();
2260
2261 // Set the Parent field, then back to its old value once we're done.
2262 SetParentRAII SetParent(Parent, StmtParent, LI.getParent());
2263
2264 switch (LI.getKind()) {
2265 case VisitorJob::DeclVisitKind: {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002266 const Decl *D = cast<DeclVisit>(&LI)->get();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002267 if (!D)
2268 continue;
2269
2270 // For now, perform default visitation for Decls.
2271 if (Visit(MakeCXCursor(D, TU, RegionOfInterest,
2272 cast<DeclVisit>(&LI)->isFirst())))
2273 return true;
2274
2275 continue;
2276 }
2277 case VisitorJob::ExplicitTemplateArgsVisitKind: {
2278 const ASTTemplateArgumentListInfo *ArgList =
2279 cast<ExplicitTemplateArgsVisit>(&LI)->get();
2280 for (const TemplateArgumentLoc *Arg = ArgList->getTemplateArgs(),
2281 *ArgEnd = Arg + ArgList->NumTemplateArgs;
2282 Arg != ArgEnd; ++Arg) {
2283 if (VisitTemplateArgumentLoc(*Arg))
2284 return true;
2285 }
2286 continue;
2287 }
2288 case VisitorJob::TypeLocVisitKind: {
2289 // Perform default visitation for TypeLocs.
2290 if (Visit(cast<TypeLocVisit>(&LI)->get()))
2291 return true;
2292 continue;
2293 }
2294 case VisitorJob::LabelRefVisitKind: {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002295 const LabelDecl *LS = cast<LabelRefVisit>(&LI)->get();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002296 if (LabelStmt *stmt = LS->getStmt()) {
2297 if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(),
2298 TU))) {
2299 return true;
2300 }
2301 }
2302 continue;
2303 }
2304
2305 case VisitorJob::NestedNameSpecifierLocVisitKind: {
2306 NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI);
2307 if (VisitNestedNameSpecifierLoc(V->get()))
2308 return true;
2309 continue;
2310 }
2311
2312 case VisitorJob::DeclarationNameInfoVisitKind: {
2313 if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI)
2314 ->get()))
2315 return true;
2316 continue;
2317 }
2318 case VisitorJob::MemberRefVisitKind: {
2319 MemberRefVisit *V = cast<MemberRefVisit>(&LI);
2320 if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU)))
2321 return true;
2322 continue;
2323 }
2324 case VisitorJob::StmtVisitKind: {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002325 const Stmt *S = cast<StmtVisit>(&LI)->get();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002326 if (!S)
2327 continue;
2328
2329 // Update the current cursor.
2330 CXCursor Cursor = MakeCXCursor(S, StmtParent, TU, RegionOfInterest);
2331 if (!IsInRegionOfInterest(Cursor))
2332 continue;
2333 switch (Visitor(Cursor, Parent, ClientData)) {
2334 case CXChildVisit_Break: return true;
2335 case CXChildVisit_Continue: break;
2336 case CXChildVisit_Recurse:
2337 if (PostChildrenVisitor)
2338 WL.push_back(PostChildrenVisit(0, Cursor));
2339 EnqueueWorkList(WL, S);
2340 break;
2341 }
2342 continue;
2343 }
2344 case VisitorJob::MemberExprPartsKind: {
2345 // Handle the other pieces in the MemberExpr besides the base.
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002346 const MemberExpr *M = cast<MemberExprParts>(&LI)->get();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002347
2348 // Visit the nested-name-specifier
2349 if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc())
2350 if (VisitNestedNameSpecifierLoc(QualifierLoc))
2351 return true;
2352
2353 // Visit the declaration name.
2354 if (VisitDeclarationNameInfo(M->getMemberNameInfo()))
2355 return true;
2356
2357 // Visit the explicitly-specified template arguments, if any.
2358 if (M->hasExplicitTemplateArgs()) {
2359 for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(),
2360 *ArgEnd = Arg + M->getNumTemplateArgs();
2361 Arg != ArgEnd; ++Arg) {
2362 if (VisitTemplateArgumentLoc(*Arg))
2363 return true;
2364 }
2365 }
2366 continue;
2367 }
2368 case VisitorJob::DeclRefExprPartsKind: {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002369 const DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002370 // Visit nested-name-specifier, if present.
2371 if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc())
2372 if (VisitNestedNameSpecifierLoc(QualifierLoc))
2373 return true;
2374 // Visit declaration name.
2375 if (VisitDeclarationNameInfo(DR->getNameInfo()))
2376 return true;
2377 continue;
2378 }
2379 case VisitorJob::OverloadExprPartsKind: {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002380 const OverloadExpr *O = cast<OverloadExprParts>(&LI)->get();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002381 // Visit the nested-name-specifier.
2382 if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc())
2383 if (VisitNestedNameSpecifierLoc(QualifierLoc))
2384 return true;
2385 // Visit the declaration name.
2386 if (VisitDeclarationNameInfo(O->getNameInfo()))
2387 return true;
2388 // Visit the overloaded declaration reference.
2389 if (Visit(MakeCursorOverloadedDeclRef(O, TU)))
2390 return true;
2391 continue;
2392 }
2393 case VisitorJob::SizeOfPackExprPartsKind: {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002394 const SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002395 NamedDecl *Pack = E->getPack();
2396 if (isa<TemplateTypeParmDecl>(Pack)) {
2397 if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack),
2398 E->getPackLoc(), TU)))
2399 return true;
2400
2401 continue;
2402 }
2403
2404 if (isa<TemplateTemplateParmDecl>(Pack)) {
2405 if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack),
2406 E->getPackLoc(), TU)))
2407 return true;
2408
2409 continue;
2410 }
2411
2412 // Non-type template parameter packs and function parameter packs are
2413 // treated like DeclRefExpr cursors.
2414 continue;
2415 }
2416
2417 case VisitorJob::LambdaExprPartsKind: {
2418 // Visit captures.
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002419 const LambdaExpr *E = cast<LambdaExprParts>(&LI)->get();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002420 for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(),
2421 CEnd = E->explicit_capture_end();
2422 C != CEnd; ++C) {
Richard Smith0d8e9642013-05-16 06:20:58 +00002423 // FIXME: Lambda init-captures.
2424 if (!C->capturesVariable())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002425 continue;
Richard Smith0d8e9642013-05-16 06:20:58 +00002426
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002427 if (Visit(MakeCursorVariableRef(C->getCapturedVar(),
2428 C->getLocation(),
2429 TU)))
2430 return true;
2431 }
2432
2433 // Visit parameters and return type, if present.
2434 if (E->hasExplicitParameters() || E->hasExplicitResultType()) {
2435 TypeLoc TL = E->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
2436 if (E->hasExplicitParameters() && E->hasExplicitResultType()) {
2437 // Visit the whole type.
2438 if (Visit(TL))
2439 return true;
David Blaikie39e6ab42013-02-18 22:06:02 +00002440 } else if (FunctionProtoTypeLoc Proto =
2441 TL.getAs<FunctionProtoTypeLoc>()) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002442 if (E->hasExplicitParameters()) {
2443 // Visit parameters.
2444 for (unsigned I = 0, N = Proto.getNumArgs(); I != N; ++I)
2445 if (Visit(MakeCXCursor(Proto.getArg(I), TU)))
2446 return true;
2447 } else {
2448 // Visit result type.
2449 if (Visit(Proto.getResultLoc()))
2450 return true;
2451 }
2452 }
2453 }
2454 break;
2455 }
2456
2457 case VisitorJob::PostChildrenVisitKind:
2458 if (PostChildrenVisitor(Parent, ClientData))
2459 return true;
2460 break;
2461 }
2462 }
2463 return false;
2464}
2465
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00002466bool CursorVisitor::Visit(const Stmt *S) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002467 VisitorWorkList *WL = 0;
2468 if (!WorkListFreeList.empty()) {
2469 WL = WorkListFreeList.back();
2470 WL->clear();
2471 WorkListFreeList.pop_back();
2472 }
2473 else {
2474 WL = new VisitorWorkList();
2475 WorkListCache.push_back(WL);
2476 }
2477 EnqueueWorkList(*WL, S);
2478 bool result = RunVisitorWorkList(*WL);
2479 WorkListFreeList.push_back(WL);
2480 return result;
2481}
2482
2483namespace {
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00002484typedef SmallVector<SourceRange, 4> RefNamePieces;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002485RefNamePieces buildPieces(unsigned NameFlags, bool IsMemberRefExpr,
2486 const DeclarationNameInfo &NI,
2487 const SourceRange &QLoc,
2488 const ASTTemplateArgumentListInfo *TemplateArgs = 0){
2489 const bool WantQualifier = NameFlags & CXNameRange_WantQualifier;
2490 const bool WantTemplateArgs = NameFlags & CXNameRange_WantTemplateArgs;
2491 const bool WantSinglePiece = NameFlags & CXNameRange_WantSinglePiece;
2492
2493 const DeclarationName::NameKind Kind = NI.getName().getNameKind();
2494
2495 RefNamePieces Pieces;
2496
2497 if (WantQualifier && QLoc.isValid())
2498 Pieces.push_back(QLoc);
2499
2500 if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr)
2501 Pieces.push_back(NI.getLoc());
2502
2503 if (WantTemplateArgs && TemplateArgs)
2504 Pieces.push_back(SourceRange(TemplateArgs->LAngleLoc,
2505 TemplateArgs->RAngleLoc));
2506
2507 if (Kind == DeclarationName::CXXOperatorName) {
2508 Pieces.push_back(SourceLocation::getFromRawEncoding(
2509 NI.getInfo().CXXOperatorName.BeginOpNameLoc));
2510 Pieces.push_back(SourceLocation::getFromRawEncoding(
2511 NI.getInfo().CXXOperatorName.EndOpNameLoc));
2512 }
2513
2514 if (WantSinglePiece) {
2515 SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd());
2516 Pieces.clear();
2517 Pieces.push_back(R);
2518 }
2519
2520 return Pieces;
2521}
2522}
2523
2524//===----------------------------------------------------------------------===//
2525// Misc. API hooks.
2526//===----------------------------------------------------------------------===//
2527
2528static llvm::sys::Mutex EnableMultithreadingMutex;
2529static bool EnabledMultithreading;
2530
Chad Rosier90836282013-03-27 18:28:23 +00002531static void fatal_error_handler(void *user_data, const std::string& reason,
2532 bool gen_crash_diag) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002533 // Write the result out to stderr avoiding errs() because raw_ostreams can
2534 // call report_fatal_error.
2535 fprintf(stderr, "LIBCLANG FATAL ERROR: %s\n", reason.c_str());
2536 ::abort();
2537}
2538
2539extern "C" {
2540CXIndex clang_createIndex(int excludeDeclarationsFromPCH,
2541 int displayDiagnostics) {
2542 // Disable pretty stack trace functionality, which will otherwise be a very
2543 // poor citizen of the world and set up all sorts of signal handlers.
2544 llvm::DisablePrettyStackTrace = true;
2545
2546 // We use crash recovery to make some of our APIs more reliable, implicitly
2547 // enable it.
2548 llvm::CrashRecoveryContext::Enable();
2549
2550 // Enable support for multithreading in LLVM.
2551 {
2552 llvm::sys::ScopedLock L(EnableMultithreadingMutex);
2553 if (!EnabledMultithreading) {
2554 llvm::install_fatal_error_handler(fatal_error_handler, 0);
2555 llvm::llvm_start_multithreaded();
2556 EnabledMultithreading = true;
2557 }
2558 }
2559
2560 CIndexer *CIdxr = new CIndexer();
2561 if (excludeDeclarationsFromPCH)
2562 CIdxr->setOnlyLocalDecls();
2563 if (displayDiagnostics)
2564 CIdxr->setDisplayDiagnostics();
2565
2566 if (getenv("LIBCLANG_BGPRIO_INDEX"))
2567 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() |
2568 CXGlobalOpt_ThreadBackgroundPriorityForIndexing);
2569 if (getenv("LIBCLANG_BGPRIO_EDIT"))
2570 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() |
2571 CXGlobalOpt_ThreadBackgroundPriorityForEditing);
2572
2573 return CIdxr;
2574}
2575
2576void clang_disposeIndex(CXIndex CIdx) {
2577 if (CIdx)
2578 delete static_cast<CIndexer *>(CIdx);
2579}
2580
2581void clang_CXIndex_setGlobalOptions(CXIndex CIdx, unsigned options) {
2582 if (CIdx)
2583 static_cast<CIndexer *>(CIdx)->setCXGlobalOptFlags(options);
2584}
2585
2586unsigned clang_CXIndex_getGlobalOptions(CXIndex CIdx) {
2587 if (CIdx)
2588 return static_cast<CIndexer *>(CIdx)->getCXGlobalOptFlags();
2589 return 0;
2590}
2591
2592void clang_toggleCrashRecovery(unsigned isEnabled) {
2593 if (isEnabled)
2594 llvm::CrashRecoveryContext::Enable();
2595 else
2596 llvm::CrashRecoveryContext::Disable();
2597}
2598
2599CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx,
2600 const char *ast_filename) {
Argyrios Kyrtzidis4c9f58f2013-05-24 22:24:07 +00002601 if (!CIdx || !ast_filename)
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002602 return 0;
2603
Argyrios Kyrtzidis4c9f58f2013-05-24 22:24:07 +00002604 LOG_FUNC_SECTION {
2605 *Log << ast_filename;
2606 }
2607
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002608 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
2609 FileSystemOptions FileSystemOpts;
2610
2611 IntrusiveRefCntPtr<DiagnosticsEngine> Diags;
2612 ASTUnit *TU = ASTUnit::LoadFromASTFile(ast_filename, Diags, FileSystemOpts,
2613 CXXIdx->getOnlyLocalDecls(),
2614 0, 0,
2615 /*CaptureDiagnostics=*/true,
2616 /*AllowPCHWithCompilerErrors=*/true,
2617 /*UserFilesAreVolatile=*/true);
2618 return MakeCXTranslationUnit(CXXIdx, TU);
2619}
2620
2621unsigned clang_defaultEditingTranslationUnitOptions() {
2622 return CXTranslationUnit_PrecompiledPreamble |
2623 CXTranslationUnit_CacheCompletionResults;
2624}
2625
2626CXTranslationUnit
2627clang_createTranslationUnitFromSourceFile(CXIndex CIdx,
2628 const char *source_filename,
2629 int num_command_line_args,
2630 const char * const *command_line_args,
2631 unsigned num_unsaved_files,
2632 struct CXUnsavedFile *unsaved_files) {
2633 unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord;
2634 return clang_parseTranslationUnit(CIdx, source_filename,
2635 command_line_args, num_command_line_args,
2636 unsaved_files, num_unsaved_files,
2637 Options);
2638}
2639
2640struct ParseTranslationUnitInfo {
2641 CXIndex CIdx;
2642 const char *source_filename;
2643 const char *const *command_line_args;
2644 int num_command_line_args;
2645 struct CXUnsavedFile *unsaved_files;
2646 unsigned num_unsaved_files;
2647 unsigned options;
2648 CXTranslationUnit result;
2649};
2650static void clang_parseTranslationUnit_Impl(void *UserData) {
2651 ParseTranslationUnitInfo *PTUI =
2652 static_cast<ParseTranslationUnitInfo*>(UserData);
2653 CXIndex CIdx = PTUI->CIdx;
2654 const char *source_filename = PTUI->source_filename;
2655 const char * const *command_line_args = PTUI->command_line_args;
2656 int num_command_line_args = PTUI->num_command_line_args;
2657 struct CXUnsavedFile *unsaved_files = PTUI->unsaved_files;
2658 unsigned num_unsaved_files = PTUI->num_unsaved_files;
2659 unsigned options = PTUI->options;
2660 PTUI->result = 0;
2661
2662 if (!CIdx)
2663 return;
2664
2665 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
2666
2667 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
2668 setThreadBackgroundPriority();
2669
2670 bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble;
2671 // FIXME: Add a flag for modules.
2672 TranslationUnitKind TUKind
2673 = (options & CXTranslationUnit_Incomplete)? TU_Prefix : TU_Complete;
2674 bool CacheCodeCompetionResults
2675 = options & CXTranslationUnit_CacheCompletionResults;
2676 bool IncludeBriefCommentsInCodeCompletion
2677 = options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion;
2678 bool SkipFunctionBodies = options & CXTranslationUnit_SkipFunctionBodies;
2679 bool ForSerialization = options & CXTranslationUnit_ForSerialization;
2680
2681 // Configure the diagnostics.
2682 IntrusiveRefCntPtr<DiagnosticsEngine>
Sean Silvad47afb92013-01-20 01:58:28 +00002683 Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions));
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002684
2685 // Recover resources if we crash before exiting this function.
2686 llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
2687 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
2688 DiagCleanup(Diags.getPtr());
2689
2690 OwningPtr<std::vector<ASTUnit::RemappedFile> >
2691 RemappedFiles(new std::vector<ASTUnit::RemappedFile>());
2692
2693 // Recover resources if we crash before exiting this function.
2694 llvm::CrashRecoveryContextCleanupRegistrar<
2695 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
2696
2697 for (unsigned I = 0; I != num_unsaved_files; ++I) {
2698 StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length);
2699 const llvm::MemoryBuffer *Buffer
2700 = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename);
2701 RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename,
2702 Buffer));
2703 }
2704
2705 OwningPtr<std::vector<const char *> >
2706 Args(new std::vector<const char*>());
2707
2708 // Recover resources if we crash before exiting this method.
2709 llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> >
2710 ArgsCleanup(Args.get());
2711
2712 // Since the Clang C library is primarily used by batch tools dealing with
2713 // (often very broken) source code, where spell-checking can have a
2714 // significant negative impact on performance (particularly when
2715 // precompiled headers are involved), we disable it by default.
2716 // Only do this if we haven't found a spell-checking-related argument.
2717 bool FoundSpellCheckingArgument = false;
2718 for (int I = 0; I != num_command_line_args; ++I) {
2719 if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 ||
2720 strcmp(command_line_args[I], "-fspell-checking") == 0) {
2721 FoundSpellCheckingArgument = true;
2722 break;
2723 }
2724 }
2725 if (!FoundSpellCheckingArgument)
2726 Args->push_back("-fno-spell-checking");
2727
2728 Args->insert(Args->end(), command_line_args,
2729 command_line_args + num_command_line_args);
2730
2731 // The 'source_filename' argument is optional. If the caller does not
2732 // specify it then it is assumed that the source file is specified
2733 // in the actual argument list.
2734 // Put the source file after command_line_args otherwise if '-x' flag is
2735 // present it will be unused.
2736 if (source_filename)
2737 Args->push_back(source_filename);
2738
2739 // Do we need the detailed preprocessing record?
2740 if (options & CXTranslationUnit_DetailedPreprocessingRecord) {
2741 Args->push_back("-Xclang");
2742 Args->push_back("-detailed-preprocessing-record");
2743 }
2744
2745 unsigned NumErrors = Diags->getClient()->getNumErrors();
2746 OwningPtr<ASTUnit> ErrUnit;
2747 OwningPtr<ASTUnit> Unit(
2748 ASTUnit::LoadFromCommandLine(Args->size() ? &(*Args)[0] : 0
2749 /* vector::data() not portable */,
2750 Args->size() ? (&(*Args)[0] + Args->size()) :0,
2751 Diags,
2752 CXXIdx->getClangResourcesPath(),
2753 CXXIdx->getOnlyLocalDecls(),
2754 /*CaptureDiagnostics=*/true,
2755 RemappedFiles->size() ? &(*RemappedFiles)[0]:0,
2756 RemappedFiles->size(),
2757 /*RemappedFilesKeepOriginalName=*/true,
2758 PrecompilePreamble,
2759 TUKind,
2760 CacheCodeCompetionResults,
2761 IncludeBriefCommentsInCodeCompletion,
2762 /*AllowPCHWithCompilerErrors=*/true,
2763 SkipFunctionBodies,
2764 /*UserFilesAreVolatile=*/true,
2765 ForSerialization,
2766 &ErrUnit));
2767
2768 if (NumErrors != Diags->getClient()->getNumErrors()) {
2769 // Make sure to check that 'Unit' is non-NULL.
2770 if (CXXIdx->getDisplayDiagnostics())
2771 printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get());
2772 }
2773
2774 PTUI->result = MakeCXTranslationUnit(CXXIdx, Unit.take());
2775}
2776CXTranslationUnit clang_parseTranslationUnit(CXIndex CIdx,
2777 const char *source_filename,
2778 const char * const *command_line_args,
2779 int num_command_line_args,
2780 struct CXUnsavedFile *unsaved_files,
2781 unsigned num_unsaved_files,
2782 unsigned options) {
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00002783 LOG_FUNC_SECTION {
2784 *Log << source_filename << ": ";
2785 for (int i = 0; i != num_command_line_args; ++i)
2786 *Log << command_line_args[i] << " ";
2787 }
2788
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002789 ParseTranslationUnitInfo PTUI = { CIdx, source_filename, command_line_args,
2790 num_command_line_args, unsaved_files,
2791 num_unsaved_files, options, 0 };
2792 llvm::CrashRecoveryContext CRC;
2793
2794 if (!RunSafely(CRC, clang_parseTranslationUnit_Impl, &PTUI)) {
2795 fprintf(stderr, "libclang: crash detected during parsing: {\n");
2796 fprintf(stderr, " 'source_filename' : '%s'\n", source_filename);
2797 fprintf(stderr, " 'command_line_args' : [");
2798 for (int i = 0; i != num_command_line_args; ++i) {
2799 if (i)
2800 fprintf(stderr, ", ");
2801 fprintf(stderr, "'%s'", command_line_args[i]);
2802 }
2803 fprintf(stderr, "],\n");
2804 fprintf(stderr, " 'unsaved_files' : [");
2805 for (unsigned i = 0; i != num_unsaved_files; ++i) {
2806 if (i)
2807 fprintf(stderr, ", ");
2808 fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename,
2809 unsaved_files[i].Length);
2810 }
2811 fprintf(stderr, "],\n");
2812 fprintf(stderr, " 'options' : %d,\n", options);
2813 fprintf(stderr, "}\n");
2814
2815 return 0;
2816 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
2817 PrintLibclangResourceUsage(PTUI.result);
2818 }
2819
2820 return PTUI.result;
2821}
2822
2823unsigned clang_defaultSaveOptions(CXTranslationUnit TU) {
2824 return CXSaveTranslationUnit_None;
2825}
2826
2827namespace {
2828
2829struct SaveTranslationUnitInfo {
2830 CXTranslationUnit TU;
2831 const char *FileName;
2832 unsigned options;
2833 CXSaveError result;
2834};
2835
2836}
2837
2838static void clang_saveTranslationUnit_Impl(void *UserData) {
2839 SaveTranslationUnitInfo *STUI =
2840 static_cast<SaveTranslationUnitInfo*>(UserData);
2841
Dmitri Gribenko8c718e72013-01-26 21:49:50 +00002842 CIndexer *CXXIdx = STUI->TU->CIdx;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002843 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
2844 setThreadBackgroundPriority();
2845
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00002846 bool hadError = cxtu::getASTUnit(STUI->TU)->Save(STUI->FileName);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002847 STUI->result = hadError ? CXSaveError_Unknown : CXSaveError_None;
2848}
2849
2850int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName,
2851 unsigned options) {
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00002852 LOG_FUNC_SECTION {
2853 *Log << TU << ' ' << FileName;
2854 }
2855
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002856 if (!TU)
2857 return CXSaveError_InvalidTU;
2858
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00002859 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002860 ASTUnit::ConcurrencyCheck Check(*CXXUnit);
2861 if (!CXXUnit->hasSema())
2862 return CXSaveError_InvalidTU;
2863
2864 SaveTranslationUnitInfo STUI = { TU, FileName, options, CXSaveError_None };
2865
2866 if (!CXXUnit->getDiagnostics().hasUnrecoverableErrorOccurred() ||
2867 getenv("LIBCLANG_NOTHREADS")) {
2868 clang_saveTranslationUnit_Impl(&STUI);
2869
2870 if (getenv("LIBCLANG_RESOURCE_USAGE"))
2871 PrintLibclangResourceUsage(TU);
2872
2873 return STUI.result;
2874 }
2875
2876 // We have an AST that has invalid nodes due to compiler errors.
2877 // Use a crash recovery thread for protection.
2878
2879 llvm::CrashRecoveryContext CRC;
2880
2881 if (!RunSafely(CRC, clang_saveTranslationUnit_Impl, &STUI)) {
2882 fprintf(stderr, "libclang: crash detected during AST saving: {\n");
2883 fprintf(stderr, " 'filename' : '%s'\n", FileName);
2884 fprintf(stderr, " 'options' : %d,\n", options);
2885 fprintf(stderr, "}\n");
2886
2887 return CXSaveError_Unknown;
2888
2889 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
2890 PrintLibclangResourceUsage(TU);
2891 }
2892
2893 return STUI.result;
2894}
2895
2896void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) {
2897 if (CTUnit) {
2898 // If the translation unit has been marked as unsafe to free, just discard
2899 // it.
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00002900 if (cxtu::getASTUnit(CTUnit)->isUnsafeToFree())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002901 return;
2902
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00002903 delete cxtu::getASTUnit(CTUnit);
Dmitri Gribenko9c48d162013-01-26 22:44:19 +00002904 delete CTUnit->StringPool;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002905 delete static_cast<CXDiagnosticSetImpl *>(CTUnit->Diagnostics);
2906 disposeOverridenCXCursorsPool(CTUnit->OverridenCursorsPool);
Dmitri Gribenko337ee242013-01-26 21:39:50 +00002907 delete CTUnit->FormatContext;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002908 delete CTUnit;
2909 }
2910}
2911
2912unsigned clang_defaultReparseOptions(CXTranslationUnit TU) {
2913 return CXReparse_None;
2914}
2915
2916struct ReparseTranslationUnitInfo {
2917 CXTranslationUnit TU;
2918 unsigned num_unsaved_files;
2919 struct CXUnsavedFile *unsaved_files;
2920 unsigned options;
2921 int result;
2922};
2923
2924static void clang_reparseTranslationUnit_Impl(void *UserData) {
2925 ReparseTranslationUnitInfo *RTUI =
2926 static_cast<ReparseTranslationUnitInfo*>(UserData);
2927 CXTranslationUnit TU = RTUI->TU;
Argyrios Kyrtzidisd7bf4a42013-01-16 18:13:00 +00002928 if (!TU)
2929 return;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002930
2931 // Reset the associated diagnostics.
2932 delete static_cast<CXDiagnosticSetImpl*>(TU->Diagnostics);
2933 TU->Diagnostics = 0;
2934
2935 unsigned num_unsaved_files = RTUI->num_unsaved_files;
2936 struct CXUnsavedFile *unsaved_files = RTUI->unsaved_files;
2937 unsigned options = RTUI->options;
2938 (void) options;
2939 RTUI->result = 1;
2940
Dmitri Gribenko8c718e72013-01-26 21:49:50 +00002941 CIndexer *CXXIdx = TU->CIdx;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002942 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
2943 setThreadBackgroundPriority();
2944
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00002945 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002946 ASTUnit::ConcurrencyCheck Check(*CXXUnit);
2947
2948 OwningPtr<std::vector<ASTUnit::RemappedFile> >
2949 RemappedFiles(new std::vector<ASTUnit::RemappedFile>());
2950
2951 // Recover resources if we crash before exiting this function.
2952 llvm::CrashRecoveryContextCleanupRegistrar<
2953 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
2954
2955 for (unsigned I = 0; I != num_unsaved_files; ++I) {
2956 StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length);
2957 const llvm::MemoryBuffer *Buffer
2958 = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename);
2959 RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename,
2960 Buffer));
2961 }
2962
2963 if (!CXXUnit->Reparse(RemappedFiles->size() ? &(*RemappedFiles)[0] : 0,
2964 RemappedFiles->size()))
2965 RTUI->result = 0;
2966}
2967
2968int clang_reparseTranslationUnit(CXTranslationUnit TU,
2969 unsigned num_unsaved_files,
2970 struct CXUnsavedFile *unsaved_files,
2971 unsigned options) {
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00002972 LOG_FUNC_SECTION {
2973 *Log << TU;
2974 }
2975
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002976 ReparseTranslationUnitInfo RTUI = { TU, num_unsaved_files, unsaved_files,
2977 options, 0 };
2978
2979 if (getenv("LIBCLANG_NOTHREADS")) {
2980 clang_reparseTranslationUnit_Impl(&RTUI);
2981 return RTUI.result;
2982 }
2983
2984 llvm::CrashRecoveryContext CRC;
2985
2986 if (!RunSafely(CRC, clang_reparseTranslationUnit_Impl, &RTUI)) {
2987 fprintf(stderr, "libclang: crash detected during reparsing\n");
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00002988 cxtu::getASTUnit(TU)->setUnsafeToFree(true);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00002989 return 1;
2990 } else if (getenv("LIBCLANG_RESOURCE_USAGE"))
2991 PrintLibclangResourceUsage(TU);
2992
2993 return RTUI.result;
2994}
2995
2996
2997CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) {
2998 if (!CTUnit)
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00002999 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003000
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00003001 ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003002 return cxstring::createDup(CXXUnit->getOriginalSourceFileName());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003003}
3004
3005CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) {
Argyrios Kyrtzidis0b602832013-04-04 22:40:59 +00003006 if (!TU)
3007 return clang_getNullCursor();
3008
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00003009 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003010 return MakeCXCursor(CXXUnit->getASTContext().getTranslationUnitDecl(), TU);
3011}
3012
3013} // end: extern "C"
3014
3015//===----------------------------------------------------------------------===//
3016// CXFile Operations.
3017//===----------------------------------------------------------------------===//
3018
3019extern "C" {
3020CXString clang_getFileName(CXFile SFile) {
3021 if (!SFile)
Dmitri Gribenkodad4c1a2013-02-01 14:13:32 +00003022 return cxstring::createNull();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003023
3024 FileEntry *FEnt = static_cast<FileEntry *>(SFile);
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003025 return cxstring::createRef(FEnt->getName());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003026}
3027
3028time_t clang_getFileTime(CXFile SFile) {
3029 if (!SFile)
3030 return 0;
3031
3032 FileEntry *FEnt = static_cast<FileEntry *>(SFile);
3033 return FEnt->getModificationTime();
3034}
3035
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00003036CXFile clang_getFile(CXTranslationUnit TU, const char *file_name) {
3037 if (!TU)
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003038 return 0;
3039
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00003040 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003041
3042 FileManager &FMgr = CXXUnit->getFileManager();
3043 return const_cast<FileEntry *>(FMgr.getFile(file_name));
3044}
3045
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00003046unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit TU, CXFile file) {
3047 if (!TU || !file)
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003048 return 0;
3049
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00003050 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003051 FileEntry *FEnt = static_cast<FileEntry *>(file);
3052 return CXXUnit->getPreprocessor().getHeaderSearchInfo()
3053 .isFileMultipleIncludeGuarded(FEnt);
3054}
3055
Argyrios Kyrtzidisdb84e7a2013-01-26 04:52:52 +00003056int clang_getFileUniqueID(CXFile file, CXFileUniqueID *outID) {
3057 if (!file || !outID)
3058 return 1;
3059
3060#ifdef LLVM_ON_WIN32
3061 return 1; // inodes not supported on windows.
3062#else
3063 FileEntry *FEnt = static_cast<FileEntry *>(file);
3064 outID->data[0] = FEnt->getDevice();
3065 outID->data[1] = FEnt->getInode();
3066 outID->data[2] = FEnt->getModificationTime();
3067 return 0;
3068#endif
3069}
3070
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003071} // end: extern "C"
3072
3073//===----------------------------------------------------------------------===//
3074// CXCursor Operations.
3075//===----------------------------------------------------------------------===//
3076
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003077static const Decl *getDeclFromExpr(const Stmt *E) {
3078 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003079 return getDeclFromExpr(CE->getSubExpr());
3080
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003081 if (const DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003082 return RefExpr->getDecl();
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003083 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003084 return ME->getMemberDecl();
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003085 if (const ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003086 return RE->getDecl();
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003087 if (const ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003088 if (PRE->isExplicitProperty())
3089 return PRE->getExplicitProperty();
3090 // It could be messaging both getter and setter as in:
3091 // ++myobj.myprop;
3092 // in which case prefer to associate the setter since it is less obvious
3093 // from inspecting the source that the setter is going to get called.
3094 if (PRE->isMessagingSetter())
3095 return PRE->getImplicitPropertySetter();
3096 return PRE->getImplicitPropertyGetter();
3097 }
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003098 if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003099 return getDeclFromExpr(POE->getSyntacticForm());
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003100 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003101 if (Expr *Src = OVE->getSourceExpr())
3102 return getDeclFromExpr(Src);
3103
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003104 if (const CallExpr *CE = dyn_cast<CallExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003105 return getDeclFromExpr(CE->getCallee());
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003106 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003107 if (!CE->isElidable())
3108 return CE->getConstructor();
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003109 if (const ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003110 return OME->getMethodDecl();
3111
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003112 if (const ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003113 return PE->getProtocol();
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003114 if (const SubstNonTypeTemplateParmPackExpr *NTTP
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003115 = dyn_cast<SubstNonTypeTemplateParmPackExpr>(E))
3116 return NTTP->getParameterPack();
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003117 if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003118 if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) ||
3119 isa<ParmVarDecl>(SizeOfPack->getPack()))
3120 return SizeOfPack->getPack();
3121
3122 return 0;
3123}
3124
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00003125static SourceLocation getLocationFromExpr(const Expr *E) {
3126 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003127 return getLocationFromExpr(CE->getSubExpr());
3128
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00003129 if (const ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003130 return /*FIXME:*/Msg->getLeftLoc();
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00003131 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003132 return DRE->getLocation();
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00003133 if (const MemberExpr *Member = dyn_cast<MemberExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003134 return Member->getMemberLoc();
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00003135 if (const ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003136 return Ivar->getLocation();
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00003137 if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003138 return SizeOfPack->getPackLoc();
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00003139 if (const ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003140 return PropRef->getLocation();
3141
3142 return E->getLocStart();
3143}
3144
3145extern "C" {
3146
3147unsigned clang_visitChildren(CXCursor parent,
3148 CXCursorVisitor visitor,
3149 CXClientData client_data) {
3150 CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data,
3151 /*VisitPreprocessorLast=*/false);
3152 return CursorVis.VisitChildren(parent);
3153}
3154
3155#ifndef __has_feature
3156#define __has_feature(x) 0
3157#endif
3158#if __has_feature(blocks)
3159typedef enum CXChildVisitResult
3160 (^CXCursorVisitorBlock)(CXCursor cursor, CXCursor parent);
3161
3162static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
3163 CXClientData client_data) {
3164 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
3165 return block(cursor, parent);
3166}
3167#else
3168// If we are compiled with a compiler that doesn't have native blocks support,
3169// define and call the block manually, so the
3170typedef struct _CXChildVisitResult
3171{
3172 void *isa;
3173 int flags;
3174 int reserved;
3175 enum CXChildVisitResult(*invoke)(struct _CXChildVisitResult*, CXCursor,
3176 CXCursor);
3177} *CXCursorVisitorBlock;
3178
3179static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
3180 CXClientData client_data) {
3181 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
3182 return block->invoke(block, cursor, parent);
3183}
3184#endif
3185
3186
3187unsigned clang_visitChildrenWithBlock(CXCursor parent,
3188 CXCursorVisitorBlock block) {
3189 return clang_visitChildren(parent, visitWithBlock, block);
3190}
3191
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003192static CXString getDeclSpelling(const Decl *D) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003193 if (!D)
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00003194 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003195
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003196 const NamedDecl *ND = dyn_cast<NamedDecl>(D);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003197 if (!ND) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003198 if (const ObjCPropertyImplDecl *PropImpl =
3199 dyn_cast<ObjCPropertyImplDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003200 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003201 return cxstring::createDup(Property->getIdentifier()->getName());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003202
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003203 if (const ImportDecl *ImportD = dyn_cast<ImportDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003204 if (Module *Mod = ImportD->getImportedModule())
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003205 return cxstring::createDup(Mod->getFullModuleName());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003206
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00003207 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003208 }
3209
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003210 if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003211 return cxstring::createDup(OMD->getSelector().getAsString());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003212
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003213 if (const ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003214 // No, this isn't the same as the code below. getIdentifier() is non-virtual
3215 // and returns different names. NamedDecl returns the class name and
3216 // ObjCCategoryImplDecl returns the category name.
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003217 return cxstring::createRef(CIMP->getIdentifier()->getNameStart());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003218
3219 if (isa<UsingDirectiveDecl>(D))
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00003220 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003221
3222 SmallString<1024> S;
3223 llvm::raw_svector_ostream os(S);
3224 ND->printName(os);
3225
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003226 return cxstring::createDup(os.str());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003227}
3228
3229CXString clang_getCursorSpelling(CXCursor C) {
3230 if (clang_isTranslationUnit(C.kind))
Dmitri Gribenko46f92522013-01-11 19:28:44 +00003231 return clang_getTranslationUnitSpelling(getCursorTU(C));
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003232
3233 if (clang_isReference(C.kind)) {
3234 switch (C.kind) {
3235 case CXCursor_ObjCSuperClassRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00003236 const ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first;
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003237 return cxstring::createRef(Super->getIdentifier()->getNameStart());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003238 }
3239 case CXCursor_ObjCClassRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00003240 const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003241 return cxstring::createRef(Class->getIdentifier()->getNameStart());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003242 }
3243 case CXCursor_ObjCProtocolRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00003244 const ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003245 assert(OID && "getCursorSpelling(): Missing protocol decl");
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003246 return cxstring::createRef(OID->getIdentifier()->getNameStart());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003247 }
3248 case CXCursor_CXXBaseSpecifier: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00003249 const CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C);
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003250 return cxstring::createDup(B->getType().getAsString());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003251 }
3252 case CXCursor_TypeRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00003253 const TypeDecl *Type = getCursorTypeRef(C).first;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003254 assert(Type && "Missing type decl");
3255
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003256 return cxstring::createDup(getCursorContext(C).getTypeDeclType(Type).
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003257 getAsString());
3258 }
3259 case CXCursor_TemplateRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00003260 const TemplateDecl *Template = getCursorTemplateRef(C).first;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003261 assert(Template && "Missing template decl");
3262
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003263 return cxstring::createDup(Template->getNameAsString());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003264 }
3265
3266 case CXCursor_NamespaceRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00003267 const NamedDecl *NS = getCursorNamespaceRef(C).first;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003268 assert(NS && "Missing namespace decl");
3269
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003270 return cxstring::createDup(NS->getNameAsString());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003271 }
3272
3273 case CXCursor_MemberRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00003274 const FieldDecl *Field = getCursorMemberRef(C).first;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003275 assert(Field && "Missing member decl");
3276
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003277 return cxstring::createDup(Field->getNameAsString());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003278 }
3279
3280 case CXCursor_LabelRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00003281 const LabelStmt *Label = getCursorLabelRef(C).first;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003282 assert(Label && "Missing label");
3283
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003284 return cxstring::createRef(Label->getName());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003285 }
3286
3287 case CXCursor_OverloadedDeclRef: {
3288 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003289 if (const Decl *D = Storage.dyn_cast<const Decl *>()) {
3290 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003291 return cxstring::createDup(ND->getNameAsString());
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00003292 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003293 }
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003294 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003295 return cxstring::createDup(E->getName().getAsString());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003296 OverloadedTemplateStorage *Ovl
3297 = Storage.get<OverloadedTemplateStorage*>();
3298 if (Ovl->size() == 0)
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00003299 return cxstring::createEmpty();
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003300 return cxstring::createDup((*Ovl->begin())->getNameAsString());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003301 }
3302
3303 case CXCursor_VariableRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00003304 const VarDecl *Var = getCursorVariableRef(C).first;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003305 assert(Var && "Missing variable decl");
3306
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003307 return cxstring::createDup(Var->getNameAsString());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003308 }
3309
3310 default:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003311 return cxstring::createRef("<not implemented>");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003312 }
3313 }
3314
3315 if (clang_isExpression(C.kind)) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003316 const Decl *D = getDeclFromExpr(getCursorExpr(C));
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003317 if (D)
3318 return getDeclSpelling(D);
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00003319 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003320 }
3321
3322 if (clang_isStatement(C.kind)) {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00003323 const Stmt *S = getCursorStmt(C);
3324 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003325 return cxstring::createRef(Label->getName());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003326
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00003327 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003328 }
3329
3330 if (C.kind == CXCursor_MacroExpansion)
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003331 return cxstring::createRef(getCursorMacroExpansion(C).getName()
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003332 ->getNameStart());
3333
3334 if (C.kind == CXCursor_MacroDefinition)
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003335 return cxstring::createRef(getCursorMacroDefinition(C)->getName()
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003336 ->getNameStart());
3337
3338 if (C.kind == CXCursor_InclusionDirective)
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003339 return cxstring::createDup(getCursorInclusionDirective(C)->getFileName());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003340
3341 if (clang_isDeclaration(C.kind))
3342 return getDeclSpelling(getCursorDecl(C));
3343
3344 if (C.kind == CXCursor_AnnotateAttr) {
Dmitri Gribenko7d914382013-01-26 18:08:08 +00003345 const AnnotateAttr *AA = cast<AnnotateAttr>(cxcursor::getCursorAttr(C));
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003346 return cxstring::createDup(AA->getAnnotation());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003347 }
3348
3349 if (C.kind == CXCursor_AsmLabelAttr) {
Dmitri Gribenko7d914382013-01-26 18:08:08 +00003350 const AsmLabelAttr *AA = cast<AsmLabelAttr>(cxcursor::getCursorAttr(C));
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003351 return cxstring::createDup(AA->getLabel());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003352 }
3353
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00003354 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003355}
3356
3357CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C,
3358 unsigned pieceIndex,
3359 unsigned options) {
3360 if (clang_Cursor_isNull(C))
3361 return clang_getNullRange();
3362
3363 ASTContext &Ctx = getCursorContext(C);
3364
3365 if (clang_isStatement(C.kind)) {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00003366 const Stmt *S = getCursorStmt(C);
3367 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003368 if (pieceIndex > 0)
3369 return clang_getNullRange();
3370 return cxloc::translateSourceRange(Ctx, Label->getIdentLoc());
3371 }
3372
3373 return clang_getNullRange();
3374 }
3375
3376 if (C.kind == CXCursor_ObjCMessageExpr) {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00003377 if (const ObjCMessageExpr *
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003378 ME = dyn_cast_or_null<ObjCMessageExpr>(getCursorExpr(C))) {
3379 if (pieceIndex >= ME->getNumSelectorLocs())
3380 return clang_getNullRange();
3381 return cxloc::translateSourceRange(Ctx, ME->getSelectorLoc(pieceIndex));
3382 }
3383 }
3384
3385 if (C.kind == CXCursor_ObjCInstanceMethodDecl ||
3386 C.kind == CXCursor_ObjCClassMethodDecl) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003387 if (const ObjCMethodDecl *
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003388 MD = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(C))) {
3389 if (pieceIndex >= MD->getNumSelectorLocs())
3390 return clang_getNullRange();
3391 return cxloc::translateSourceRange(Ctx, MD->getSelectorLoc(pieceIndex));
3392 }
3393 }
3394
3395 if (C.kind == CXCursor_ObjCCategoryDecl ||
3396 C.kind == CXCursor_ObjCCategoryImplDecl) {
3397 if (pieceIndex > 0)
3398 return clang_getNullRange();
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003399 if (const ObjCCategoryDecl *
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003400 CD = dyn_cast_or_null<ObjCCategoryDecl>(getCursorDecl(C)))
3401 return cxloc::translateSourceRange(Ctx, CD->getCategoryNameLoc());
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003402 if (const ObjCCategoryImplDecl *
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003403 CID = dyn_cast_or_null<ObjCCategoryImplDecl>(getCursorDecl(C)))
3404 return cxloc::translateSourceRange(Ctx, CID->getCategoryNameLoc());
3405 }
3406
3407 if (C.kind == CXCursor_ModuleImportDecl) {
3408 if (pieceIndex > 0)
3409 return clang_getNullRange();
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003410 if (const ImportDecl *ImportD =
3411 dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003412 ArrayRef<SourceLocation> Locs = ImportD->getIdentifierLocs();
3413 if (!Locs.empty())
3414 return cxloc::translateSourceRange(Ctx,
3415 SourceRange(Locs.front(), Locs.back()));
3416 }
3417 return clang_getNullRange();
3418 }
3419
3420 // FIXME: A CXCursor_InclusionDirective should give the location of the
3421 // filename, but we don't keep track of this.
3422
3423 // FIXME: A CXCursor_AnnotateAttr should give the location of the annotation
3424 // but we don't keep track of this.
3425
3426 // FIXME: A CXCursor_AsmLabelAttr should give the location of the label
3427 // but we don't keep track of this.
3428
3429 // Default handling, give the location of the cursor.
3430
3431 if (pieceIndex > 0)
3432 return clang_getNullRange();
3433
3434 CXSourceLocation CXLoc = clang_getCursorLocation(C);
3435 SourceLocation Loc = cxloc::translateSourceLocation(CXLoc);
3436 return cxloc::translateSourceRange(Ctx, Loc);
3437}
3438
3439CXString clang_getCursorDisplayName(CXCursor C) {
3440 if (!clang_isDeclaration(C.kind))
3441 return clang_getCursorSpelling(C);
3442
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003443 const Decl *D = getCursorDecl(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003444 if (!D)
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00003445 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003446
3447 PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy();
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003448 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003449 D = FunTmpl->getTemplatedDecl();
3450
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003451 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003452 SmallString<64> Str;
3453 llvm::raw_svector_ostream OS(Str);
3454 OS << *Function;
3455 if (Function->getPrimaryTemplate())
3456 OS << "<>";
3457 OS << "(";
3458 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) {
3459 if (I)
3460 OS << ", ";
3461 OS << Function->getParamDecl(I)->getType().getAsString(Policy);
3462 }
3463
3464 if (Function->isVariadic()) {
3465 if (Function->getNumParams())
3466 OS << ", ";
3467 OS << "...";
3468 }
3469 OS << ")";
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003470 return cxstring::createDup(OS.str());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003471 }
3472
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003473 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003474 SmallString<64> Str;
3475 llvm::raw_svector_ostream OS(Str);
3476 OS << *ClassTemplate;
3477 OS << "<";
3478 TemplateParameterList *Params = ClassTemplate->getTemplateParameters();
3479 for (unsigned I = 0, N = Params->size(); I != N; ++I) {
3480 if (I)
3481 OS << ", ";
3482
3483 NamedDecl *Param = Params->getParam(I);
3484 if (Param->getIdentifier()) {
3485 OS << Param->getIdentifier()->getName();
3486 continue;
3487 }
3488
3489 // There is no parameter name, which makes this tricky. Try to come up
3490 // with something useful that isn't too long.
3491 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
3492 OS << (TTP->wasDeclaredWithTypename()? "typename" : "class");
3493 else if (NonTypeTemplateParmDecl *NTTP
3494 = dyn_cast<NonTypeTemplateParmDecl>(Param))
3495 OS << NTTP->getType().getAsString(Policy);
3496 else
3497 OS << "template<...> class";
3498 }
3499
3500 OS << ">";
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003501 return cxstring::createDup(OS.str());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003502 }
3503
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003504 if (const ClassTemplateSpecializationDecl *ClassSpec
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003505 = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
3506 // If the type was explicitly written, use that.
3507 if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten())
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003508 return cxstring::createDup(TSInfo->getType().getAsString(Policy));
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003509
Benjamin Kramer5eada842013-02-22 15:46:01 +00003510 SmallString<128> Str;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003511 llvm::raw_svector_ostream OS(Str);
3512 OS << *ClassSpec;
Benjamin Kramer5eada842013-02-22 15:46:01 +00003513 TemplateSpecializationType::PrintTemplateArgumentList(OS,
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003514 ClassSpec->getTemplateArgs().data(),
3515 ClassSpec->getTemplateArgs().size(),
3516 Policy);
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00003517 return cxstring::createDup(OS.str());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003518 }
3519
3520 return clang_getCursorSpelling(C);
3521}
3522
3523CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
3524 switch (Kind) {
3525 case CXCursor_FunctionDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003526 return cxstring::createRef("FunctionDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003527 case CXCursor_TypedefDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003528 return cxstring::createRef("TypedefDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003529 case CXCursor_EnumDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003530 return cxstring::createRef("EnumDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003531 case CXCursor_EnumConstantDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003532 return cxstring::createRef("EnumConstantDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003533 case CXCursor_StructDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003534 return cxstring::createRef("StructDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003535 case CXCursor_UnionDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003536 return cxstring::createRef("UnionDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003537 case CXCursor_ClassDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003538 return cxstring::createRef("ClassDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003539 case CXCursor_FieldDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003540 return cxstring::createRef("FieldDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003541 case CXCursor_VarDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003542 return cxstring::createRef("VarDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003543 case CXCursor_ParmDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003544 return cxstring::createRef("ParmDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003545 case CXCursor_ObjCInterfaceDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003546 return cxstring::createRef("ObjCInterfaceDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003547 case CXCursor_ObjCCategoryDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003548 return cxstring::createRef("ObjCCategoryDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003549 case CXCursor_ObjCProtocolDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003550 return cxstring::createRef("ObjCProtocolDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003551 case CXCursor_ObjCPropertyDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003552 return cxstring::createRef("ObjCPropertyDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003553 case CXCursor_ObjCIvarDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003554 return cxstring::createRef("ObjCIvarDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003555 case CXCursor_ObjCInstanceMethodDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003556 return cxstring::createRef("ObjCInstanceMethodDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003557 case CXCursor_ObjCClassMethodDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003558 return cxstring::createRef("ObjCClassMethodDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003559 case CXCursor_ObjCImplementationDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003560 return cxstring::createRef("ObjCImplementationDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003561 case CXCursor_ObjCCategoryImplDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003562 return cxstring::createRef("ObjCCategoryImplDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003563 case CXCursor_CXXMethod:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003564 return cxstring::createRef("CXXMethod");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003565 case CXCursor_UnexposedDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003566 return cxstring::createRef("UnexposedDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003567 case CXCursor_ObjCSuperClassRef:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003568 return cxstring::createRef("ObjCSuperClassRef");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003569 case CXCursor_ObjCProtocolRef:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003570 return cxstring::createRef("ObjCProtocolRef");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003571 case CXCursor_ObjCClassRef:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003572 return cxstring::createRef("ObjCClassRef");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003573 case CXCursor_TypeRef:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003574 return cxstring::createRef("TypeRef");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003575 case CXCursor_TemplateRef:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003576 return cxstring::createRef("TemplateRef");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003577 case CXCursor_NamespaceRef:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003578 return cxstring::createRef("NamespaceRef");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003579 case CXCursor_MemberRef:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003580 return cxstring::createRef("MemberRef");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003581 case CXCursor_LabelRef:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003582 return cxstring::createRef("LabelRef");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003583 case CXCursor_OverloadedDeclRef:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003584 return cxstring::createRef("OverloadedDeclRef");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003585 case CXCursor_VariableRef:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003586 return cxstring::createRef("VariableRef");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003587 case CXCursor_IntegerLiteral:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003588 return cxstring::createRef("IntegerLiteral");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003589 case CXCursor_FloatingLiteral:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003590 return cxstring::createRef("FloatingLiteral");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003591 case CXCursor_ImaginaryLiteral:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003592 return cxstring::createRef("ImaginaryLiteral");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003593 case CXCursor_StringLiteral:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003594 return cxstring::createRef("StringLiteral");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003595 case CXCursor_CharacterLiteral:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003596 return cxstring::createRef("CharacterLiteral");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003597 case CXCursor_ParenExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003598 return cxstring::createRef("ParenExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003599 case CXCursor_UnaryOperator:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003600 return cxstring::createRef("UnaryOperator");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003601 case CXCursor_ArraySubscriptExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003602 return cxstring::createRef("ArraySubscriptExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003603 case CXCursor_BinaryOperator:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003604 return cxstring::createRef("BinaryOperator");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003605 case CXCursor_CompoundAssignOperator:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003606 return cxstring::createRef("CompoundAssignOperator");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003607 case CXCursor_ConditionalOperator:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003608 return cxstring::createRef("ConditionalOperator");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003609 case CXCursor_CStyleCastExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003610 return cxstring::createRef("CStyleCastExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003611 case CXCursor_CompoundLiteralExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003612 return cxstring::createRef("CompoundLiteralExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003613 case CXCursor_InitListExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003614 return cxstring::createRef("InitListExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003615 case CXCursor_AddrLabelExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003616 return cxstring::createRef("AddrLabelExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003617 case CXCursor_StmtExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003618 return cxstring::createRef("StmtExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003619 case CXCursor_GenericSelectionExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003620 return cxstring::createRef("GenericSelectionExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003621 case CXCursor_GNUNullExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003622 return cxstring::createRef("GNUNullExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003623 case CXCursor_CXXStaticCastExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003624 return cxstring::createRef("CXXStaticCastExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003625 case CXCursor_CXXDynamicCastExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003626 return cxstring::createRef("CXXDynamicCastExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003627 case CXCursor_CXXReinterpretCastExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003628 return cxstring::createRef("CXXReinterpretCastExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003629 case CXCursor_CXXConstCastExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003630 return cxstring::createRef("CXXConstCastExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003631 case CXCursor_CXXFunctionalCastExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003632 return cxstring::createRef("CXXFunctionalCastExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003633 case CXCursor_CXXTypeidExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003634 return cxstring::createRef("CXXTypeidExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003635 case CXCursor_CXXBoolLiteralExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003636 return cxstring::createRef("CXXBoolLiteralExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003637 case CXCursor_CXXNullPtrLiteralExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003638 return cxstring::createRef("CXXNullPtrLiteralExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003639 case CXCursor_CXXThisExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003640 return cxstring::createRef("CXXThisExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003641 case CXCursor_CXXThrowExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003642 return cxstring::createRef("CXXThrowExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003643 case CXCursor_CXXNewExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003644 return cxstring::createRef("CXXNewExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003645 case CXCursor_CXXDeleteExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003646 return cxstring::createRef("CXXDeleteExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003647 case CXCursor_UnaryExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003648 return cxstring::createRef("UnaryExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003649 case CXCursor_ObjCStringLiteral:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003650 return cxstring::createRef("ObjCStringLiteral");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003651 case CXCursor_ObjCBoolLiteralExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003652 return cxstring::createRef("ObjCBoolLiteralExpr");
Argyrios Kyrtzidisedab0472013-04-23 17:57:17 +00003653 case CXCursor_ObjCSelfExpr:
3654 return cxstring::createRef("ObjCSelfExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003655 case CXCursor_ObjCEncodeExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003656 return cxstring::createRef("ObjCEncodeExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003657 case CXCursor_ObjCSelectorExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003658 return cxstring::createRef("ObjCSelectorExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003659 case CXCursor_ObjCProtocolExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003660 return cxstring::createRef("ObjCProtocolExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003661 case CXCursor_ObjCBridgedCastExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003662 return cxstring::createRef("ObjCBridgedCastExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003663 case CXCursor_BlockExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003664 return cxstring::createRef("BlockExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003665 case CXCursor_PackExpansionExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003666 return cxstring::createRef("PackExpansionExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003667 case CXCursor_SizeOfPackExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003668 return cxstring::createRef("SizeOfPackExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003669 case CXCursor_LambdaExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003670 return cxstring::createRef("LambdaExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003671 case CXCursor_UnexposedExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003672 return cxstring::createRef("UnexposedExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003673 case CXCursor_DeclRefExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003674 return cxstring::createRef("DeclRefExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003675 case CXCursor_MemberRefExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003676 return cxstring::createRef("MemberRefExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003677 case CXCursor_CallExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003678 return cxstring::createRef("CallExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003679 case CXCursor_ObjCMessageExpr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003680 return cxstring::createRef("ObjCMessageExpr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003681 case CXCursor_UnexposedStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003682 return cxstring::createRef("UnexposedStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003683 case CXCursor_DeclStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003684 return cxstring::createRef("DeclStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003685 case CXCursor_LabelStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003686 return cxstring::createRef("LabelStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003687 case CXCursor_CompoundStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003688 return cxstring::createRef("CompoundStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003689 case CXCursor_CaseStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003690 return cxstring::createRef("CaseStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003691 case CXCursor_DefaultStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003692 return cxstring::createRef("DefaultStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003693 case CXCursor_IfStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003694 return cxstring::createRef("IfStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003695 case CXCursor_SwitchStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003696 return cxstring::createRef("SwitchStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003697 case CXCursor_WhileStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003698 return cxstring::createRef("WhileStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003699 case CXCursor_DoStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003700 return cxstring::createRef("DoStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003701 case CXCursor_ForStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003702 return cxstring::createRef("ForStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003703 case CXCursor_GotoStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003704 return cxstring::createRef("GotoStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003705 case CXCursor_IndirectGotoStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003706 return cxstring::createRef("IndirectGotoStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003707 case CXCursor_ContinueStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003708 return cxstring::createRef("ContinueStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003709 case CXCursor_BreakStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003710 return cxstring::createRef("BreakStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003711 case CXCursor_ReturnStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003712 return cxstring::createRef("ReturnStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003713 case CXCursor_GCCAsmStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003714 return cxstring::createRef("GCCAsmStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003715 case CXCursor_MSAsmStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003716 return cxstring::createRef("MSAsmStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003717 case CXCursor_ObjCAtTryStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003718 return cxstring::createRef("ObjCAtTryStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003719 case CXCursor_ObjCAtCatchStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003720 return cxstring::createRef("ObjCAtCatchStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003721 case CXCursor_ObjCAtFinallyStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003722 return cxstring::createRef("ObjCAtFinallyStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003723 case CXCursor_ObjCAtThrowStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003724 return cxstring::createRef("ObjCAtThrowStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003725 case CXCursor_ObjCAtSynchronizedStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003726 return cxstring::createRef("ObjCAtSynchronizedStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003727 case CXCursor_ObjCAutoreleasePoolStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003728 return cxstring::createRef("ObjCAutoreleasePoolStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003729 case CXCursor_ObjCForCollectionStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003730 return cxstring::createRef("ObjCForCollectionStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003731 case CXCursor_CXXCatchStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003732 return cxstring::createRef("CXXCatchStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003733 case CXCursor_CXXTryStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003734 return cxstring::createRef("CXXTryStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003735 case CXCursor_CXXForRangeStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003736 return cxstring::createRef("CXXForRangeStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003737 case CXCursor_SEHTryStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003738 return cxstring::createRef("SEHTryStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003739 case CXCursor_SEHExceptStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003740 return cxstring::createRef("SEHExceptStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003741 case CXCursor_SEHFinallyStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003742 return cxstring::createRef("SEHFinallyStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003743 case CXCursor_NullStmt:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003744 return cxstring::createRef("NullStmt");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003745 case CXCursor_InvalidFile:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003746 return cxstring::createRef("InvalidFile");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003747 case CXCursor_InvalidCode:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003748 return cxstring::createRef("InvalidCode");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003749 case CXCursor_NoDeclFound:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003750 return cxstring::createRef("NoDeclFound");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003751 case CXCursor_NotImplemented:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003752 return cxstring::createRef("NotImplemented");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003753 case CXCursor_TranslationUnit:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003754 return cxstring::createRef("TranslationUnit");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003755 case CXCursor_UnexposedAttr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003756 return cxstring::createRef("UnexposedAttr");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003757 case CXCursor_IBActionAttr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003758 return cxstring::createRef("attribute(ibaction)");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003759 case CXCursor_IBOutletAttr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003760 return cxstring::createRef("attribute(iboutlet)");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003761 case CXCursor_IBOutletCollectionAttr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003762 return cxstring::createRef("attribute(iboutletcollection)");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003763 case CXCursor_CXXFinalAttr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003764 return cxstring::createRef("attribute(final)");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003765 case CXCursor_CXXOverrideAttr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003766 return cxstring::createRef("attribute(override)");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003767 case CXCursor_AnnotateAttr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003768 return cxstring::createRef("attribute(annotate)");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003769 case CXCursor_AsmLabelAttr:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003770 return cxstring::createRef("asm label");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003771 case CXCursor_PreprocessingDirective:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003772 return cxstring::createRef("preprocessing directive");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003773 case CXCursor_MacroDefinition:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003774 return cxstring::createRef("macro definition");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003775 case CXCursor_MacroExpansion:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003776 return cxstring::createRef("macro expansion");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003777 case CXCursor_InclusionDirective:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003778 return cxstring::createRef("inclusion directive");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003779 case CXCursor_Namespace:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003780 return cxstring::createRef("Namespace");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003781 case CXCursor_LinkageSpec:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003782 return cxstring::createRef("LinkageSpec");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003783 case CXCursor_CXXBaseSpecifier:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003784 return cxstring::createRef("C++ base class specifier");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003785 case CXCursor_Constructor:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003786 return cxstring::createRef("CXXConstructor");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003787 case CXCursor_Destructor:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003788 return cxstring::createRef("CXXDestructor");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003789 case CXCursor_ConversionFunction:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003790 return cxstring::createRef("CXXConversion");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003791 case CXCursor_TemplateTypeParameter:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003792 return cxstring::createRef("TemplateTypeParameter");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003793 case CXCursor_NonTypeTemplateParameter:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003794 return cxstring::createRef("NonTypeTemplateParameter");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003795 case CXCursor_TemplateTemplateParameter:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003796 return cxstring::createRef("TemplateTemplateParameter");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003797 case CXCursor_FunctionTemplate:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003798 return cxstring::createRef("FunctionTemplate");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003799 case CXCursor_ClassTemplate:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003800 return cxstring::createRef("ClassTemplate");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003801 case CXCursor_ClassTemplatePartialSpecialization:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003802 return cxstring::createRef("ClassTemplatePartialSpecialization");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003803 case CXCursor_NamespaceAlias:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003804 return cxstring::createRef("NamespaceAlias");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003805 case CXCursor_UsingDirective:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003806 return cxstring::createRef("UsingDirective");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003807 case CXCursor_UsingDeclaration:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003808 return cxstring::createRef("UsingDeclaration");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003809 case CXCursor_TypeAliasDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003810 return cxstring::createRef("TypeAliasDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003811 case CXCursor_ObjCSynthesizeDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003812 return cxstring::createRef("ObjCSynthesizeDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003813 case CXCursor_ObjCDynamicDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003814 return cxstring::createRef("ObjCDynamicDecl");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003815 case CXCursor_CXXAccessSpecifier:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003816 return cxstring::createRef("CXXAccessSpecifier");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003817 case CXCursor_ModuleImportDecl:
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00003818 return cxstring::createRef("ModuleImport");
Alexey Bataev4fa7eab2013-07-19 03:13:43 +00003819 case CXCursor_OMPParallelDirective:
3820 return cxstring::createRef("OMPParallelDirective");
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003821 }
3822
3823 llvm_unreachable("Unhandled CXCursorKind");
3824}
3825
3826struct GetCursorData {
3827 SourceLocation TokenBeginLoc;
3828 bool PointsAtMacroArgExpansion;
3829 bool VisitedObjCPropertyImplDecl;
3830 SourceLocation VisitedDeclaratorDeclStartLoc;
3831 CXCursor &BestCursor;
3832
3833 GetCursorData(SourceManager &SM,
3834 SourceLocation tokenBegin, CXCursor &outputCursor)
3835 : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) {
3836 PointsAtMacroArgExpansion = SM.isMacroArgExpansion(tokenBegin);
3837 VisitedObjCPropertyImplDecl = false;
3838 }
3839};
3840
3841static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor,
3842 CXCursor parent,
3843 CXClientData client_data) {
3844 GetCursorData *Data = static_cast<GetCursorData *>(client_data);
3845 CXCursor *BestCursor = &Data->BestCursor;
3846
3847 // If we point inside a macro argument we should provide info of what the
3848 // token is so use the actual cursor, don't replace it with a macro expansion
3849 // cursor.
3850 if (cursor.kind == CXCursor_MacroExpansion && Data->PointsAtMacroArgExpansion)
3851 return CXChildVisit_Recurse;
3852
3853 if (clang_isDeclaration(cursor.kind)) {
3854 // Avoid having the implicit methods override the property decls.
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003855 if (const ObjCMethodDecl *MD
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003856 = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) {
3857 if (MD->isImplicit())
3858 return CXChildVisit_Break;
3859
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003860 } else if (const ObjCInterfaceDecl *ID
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003861 = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(cursor))) {
3862 // Check that when we have multiple @class references in the same line,
3863 // that later ones do not override the previous ones.
3864 // If we have:
3865 // @class Foo, Bar;
3866 // source ranges for both start at '@', so 'Bar' will end up overriding
3867 // 'Foo' even though the cursor location was at 'Foo'.
3868 if (BestCursor->kind == CXCursor_ObjCInterfaceDecl ||
3869 BestCursor->kind == CXCursor_ObjCClassRef)
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003870 if (const ObjCInterfaceDecl *PrevID
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003871 = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(*BestCursor))){
3872 if (PrevID != ID &&
3873 !PrevID->isThisDeclarationADefinition() &&
3874 !ID->isThisDeclarationADefinition())
3875 return CXChildVisit_Break;
3876 }
3877
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003878 } else if (const DeclaratorDecl *DD
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003879 = dyn_cast_or_null<DeclaratorDecl>(getCursorDecl(cursor))) {
3880 SourceLocation StartLoc = DD->getSourceRange().getBegin();
3881 // Check that when we have multiple declarators in the same line,
3882 // that later ones do not override the previous ones.
3883 // If we have:
3884 // int Foo, Bar;
3885 // source ranges for both start at 'int', so 'Bar' will end up overriding
3886 // 'Foo' even though the cursor location was at 'Foo'.
3887 if (Data->VisitedDeclaratorDeclStartLoc == StartLoc)
3888 return CXChildVisit_Break;
3889 Data->VisitedDeclaratorDeclStartLoc = StartLoc;
3890
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003891 } else if (const ObjCPropertyImplDecl *PropImp
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003892 = dyn_cast_or_null<ObjCPropertyImplDecl>(getCursorDecl(cursor))) {
3893 (void)PropImp;
3894 // Check that when we have multiple @synthesize in the same line,
3895 // that later ones do not override the previous ones.
3896 // If we have:
3897 // @synthesize Foo, Bar;
3898 // source ranges for both start at '@', so 'Bar' will end up overriding
3899 // 'Foo' even though the cursor location was at 'Foo'.
3900 if (Data->VisitedObjCPropertyImplDecl)
3901 return CXChildVisit_Break;
3902 Data->VisitedObjCPropertyImplDecl = true;
3903 }
3904 }
3905
3906 if (clang_isExpression(cursor.kind) &&
3907 clang_isDeclaration(BestCursor->kind)) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00003908 if (const Decl *D = getCursorDecl(*BestCursor)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003909 // Avoid having the cursor of an expression replace the declaration cursor
3910 // when the expression source range overlaps the declaration range.
3911 // This can happen for C++ constructor expressions whose range generally
3912 // include the variable declaration, e.g.:
3913 // MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl cursor.
3914 if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() &&
3915 D->getLocation() == Data->TokenBeginLoc)
3916 return CXChildVisit_Break;
3917 }
3918 }
3919
3920 // If our current best cursor is the construction of a temporary object,
3921 // don't replace that cursor with a type reference, because we want
3922 // clang_getCursor() to point at the constructor.
3923 if (clang_isExpression(BestCursor->kind) &&
3924 isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) &&
3925 cursor.kind == CXCursor_TypeRef) {
3926 // Keep the cursor pointing at CXXTemporaryObjectExpr but also mark it
3927 // as having the actual point on the type reference.
3928 *BestCursor = getTypeRefedCallExprCursor(*BestCursor);
3929 return CXChildVisit_Recurse;
3930 }
3931
3932 *BestCursor = cursor;
3933 return CXChildVisit_Recurse;
3934}
3935
3936CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) {
3937 if (!TU)
3938 return clang_getNullCursor();
3939
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00003940 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003941 ASTUnit::ConcurrencyCheck Check(*CXXUnit);
3942
3943 SourceLocation SLoc = cxloc::translateSourceLocation(Loc);
3944 CXCursor Result = cxcursor::getCursor(TU, SLoc);
3945
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00003946 LOG_FUNC_SECTION {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003947 CXFile SearchFile;
3948 unsigned SearchLine, SearchColumn;
3949 CXFile ResultFile;
3950 unsigned ResultLine, ResultColumn;
3951 CXString SearchFileName, ResultFileName, KindSpelling, USR;
3952 const char *IsDef = clang_isCursorDefinition(Result)? " (Definition)" : "";
3953 CXSourceLocation ResultLoc = clang_getCursorLocation(Result);
3954
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00003955 clang_getFileLocation(Loc, &SearchFile, &SearchLine, &SearchColumn, 0);
3956 clang_getFileLocation(ResultLoc, &ResultFile, &ResultLine,
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003957 &ResultColumn, 0);
3958 SearchFileName = clang_getFileName(SearchFile);
3959 ResultFileName = clang_getFileName(ResultFile);
3960 KindSpelling = clang_getCursorKindSpelling(Result.kind);
3961 USR = clang_getCursorUSR(Result);
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00003962 *Log << llvm::format("(%s:%d:%d) = %s",
3963 clang_getCString(SearchFileName), SearchLine, SearchColumn,
3964 clang_getCString(KindSpelling))
3965 << llvm::format("(%s:%d:%d):%s%s",
3966 clang_getCString(ResultFileName), ResultLine, ResultColumn,
3967 clang_getCString(USR), IsDef);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003968 clang_disposeString(SearchFileName);
3969 clang_disposeString(ResultFileName);
3970 clang_disposeString(KindSpelling);
3971 clang_disposeString(USR);
3972
3973 CXCursor Definition = clang_getCursorDefinition(Result);
3974 if (!clang_equalCursors(Definition, clang_getNullCursor())) {
3975 CXSourceLocation DefinitionLoc = clang_getCursorLocation(Definition);
3976 CXString DefinitionKindSpelling
3977 = clang_getCursorKindSpelling(Definition.kind);
3978 CXFile DefinitionFile;
3979 unsigned DefinitionLine, DefinitionColumn;
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00003980 clang_getFileLocation(DefinitionLoc, &DefinitionFile,
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003981 &DefinitionLine, &DefinitionColumn, 0);
3982 CXString DefinitionFileName = clang_getFileName(DefinitionFile);
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00003983 *Log << llvm::format(" -> %s(%s:%d:%d)",
3984 clang_getCString(DefinitionKindSpelling),
3985 clang_getCString(DefinitionFileName),
3986 DefinitionLine, DefinitionColumn);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00003987 clang_disposeString(DefinitionFileName);
3988 clang_disposeString(DefinitionKindSpelling);
3989 }
3990 }
3991
3992 return Result;
3993}
3994
3995CXCursor clang_getNullCursor(void) {
3996 return MakeCXCursorInvalid(CXCursor_InvalidFile);
3997}
3998
3999unsigned clang_equalCursors(CXCursor X, CXCursor Y) {
Argyrios Kyrtzidisd1d9df62013-01-08 18:23:28 +00004000 // Clear out the "FirstInDeclGroup" part in a declaration cursor, since we
4001 // can't set consistently. For example, when visiting a DeclStmt we will set
4002 // it but we don't set it on the result of clang_getCursorDefinition for
4003 // a reference of the same declaration.
4004 // FIXME: Setting "FirstInDeclGroup" in CXCursors is a hack that only works
4005 // when visiting a DeclStmt currently, the AST should be enhanced to be able
4006 // to provide that kind of info.
4007 if (clang_isDeclaration(X.kind))
4008 X.data[1] = 0;
4009 if (clang_isDeclaration(Y.kind))
4010 Y.data[1] = 0;
4011
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004012 return X == Y;
4013}
4014
4015unsigned clang_hashCursor(CXCursor C) {
4016 unsigned Index = 0;
4017 if (clang_isExpression(C.kind) || clang_isStatement(C.kind))
4018 Index = 1;
4019
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004020 return llvm::DenseMapInfo<std::pair<unsigned, const void*> >::getHashValue(
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004021 std::make_pair(C.kind, C.data[Index]));
4022}
4023
4024unsigned clang_isInvalid(enum CXCursorKind K) {
4025 return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid;
4026}
4027
4028unsigned clang_isDeclaration(enum CXCursorKind K) {
4029 return (K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl) ||
4030 (K >= CXCursor_FirstExtraDecl && K <= CXCursor_LastExtraDecl);
4031}
4032
4033unsigned clang_isReference(enum CXCursorKind K) {
4034 return K >= CXCursor_FirstRef && K <= CXCursor_LastRef;
4035}
4036
4037unsigned clang_isExpression(enum CXCursorKind K) {
4038 return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr;
4039}
4040
4041unsigned clang_isStatement(enum CXCursorKind K) {
4042 return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt;
4043}
4044
4045unsigned clang_isAttribute(enum CXCursorKind K) {
4046 return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr;
4047}
4048
4049unsigned clang_isTranslationUnit(enum CXCursorKind K) {
4050 return K == CXCursor_TranslationUnit;
4051}
4052
4053unsigned clang_isPreprocessing(enum CXCursorKind K) {
4054 return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing;
4055}
4056
4057unsigned clang_isUnexposed(enum CXCursorKind K) {
4058 switch (K) {
4059 case CXCursor_UnexposedDecl:
4060 case CXCursor_UnexposedExpr:
4061 case CXCursor_UnexposedStmt:
4062 case CXCursor_UnexposedAttr:
4063 return true;
4064 default:
4065 return false;
4066 }
4067}
4068
4069CXCursorKind clang_getCursorKind(CXCursor C) {
4070 return C.kind;
4071}
4072
4073CXSourceLocation clang_getCursorLocation(CXCursor C) {
4074 if (clang_isReference(C.kind)) {
4075 switch (C.kind) {
4076 case CXCursor_ObjCSuperClassRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004077 std::pair<const ObjCInterfaceDecl *, SourceLocation> P
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004078 = getCursorObjCSuperClassRef(C);
4079 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
4080 }
4081
4082 case CXCursor_ObjCProtocolRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004083 std::pair<const ObjCProtocolDecl *, SourceLocation> P
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004084 = getCursorObjCProtocolRef(C);
4085 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
4086 }
4087
4088 case CXCursor_ObjCClassRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004089 std::pair<const ObjCInterfaceDecl *, SourceLocation> P
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004090 = getCursorObjCClassRef(C);
4091 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
4092 }
4093
4094 case CXCursor_TypeRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004095 std::pair<const TypeDecl *, SourceLocation> P = getCursorTypeRef(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004096 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
4097 }
4098
4099 case CXCursor_TemplateRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004100 std::pair<const TemplateDecl *, SourceLocation> P =
4101 getCursorTemplateRef(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004102 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
4103 }
4104
4105 case CXCursor_NamespaceRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004106 std::pair<const NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004107 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
4108 }
4109
4110 case CXCursor_MemberRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004111 std::pair<const FieldDecl *, SourceLocation> P = getCursorMemberRef(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004112 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
4113 }
4114
4115 case CXCursor_VariableRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004116 std::pair<const VarDecl *, SourceLocation> P = getCursorVariableRef(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004117 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
4118 }
4119
4120 case CXCursor_CXXBaseSpecifier: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004121 const CXXBaseSpecifier *BaseSpec = getCursorCXXBaseSpecifier(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004122 if (!BaseSpec)
4123 return clang_getNullLocation();
4124
4125 if (TypeSourceInfo *TSInfo = BaseSpec->getTypeSourceInfo())
4126 return cxloc::translateSourceLocation(getCursorContext(C),
4127 TSInfo->getTypeLoc().getBeginLoc());
4128
4129 return cxloc::translateSourceLocation(getCursorContext(C),
4130 BaseSpec->getLocStart());
4131 }
4132
4133 case CXCursor_LabelRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004134 std::pair<const LabelStmt *, SourceLocation> P = getCursorLabelRef(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004135 return cxloc::translateSourceLocation(getCursorContext(C), P.second);
4136 }
4137
4138 case CXCursor_OverloadedDeclRef:
4139 return cxloc::translateSourceLocation(getCursorContext(C),
4140 getCursorOverloadedDeclRef(C).second);
4141
4142 default:
4143 // FIXME: Need a way to enumerate all non-reference cases.
4144 llvm_unreachable("Missed a reference kind");
4145 }
4146 }
4147
4148 if (clang_isExpression(C.kind))
4149 return cxloc::translateSourceLocation(getCursorContext(C),
4150 getLocationFromExpr(getCursorExpr(C)));
4151
4152 if (clang_isStatement(C.kind))
4153 return cxloc::translateSourceLocation(getCursorContext(C),
4154 getCursorStmt(C)->getLocStart());
4155
4156 if (C.kind == CXCursor_PreprocessingDirective) {
4157 SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin();
4158 return cxloc::translateSourceLocation(getCursorContext(C), L);
4159 }
4160
4161 if (C.kind == CXCursor_MacroExpansion) {
4162 SourceLocation L
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +00004163 = cxcursor::getCursorMacroExpansion(C).getSourceRange().getBegin();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004164 return cxloc::translateSourceLocation(getCursorContext(C), L);
4165 }
4166
4167 if (C.kind == CXCursor_MacroDefinition) {
4168 SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation();
4169 return cxloc::translateSourceLocation(getCursorContext(C), L);
4170 }
4171
4172 if (C.kind == CXCursor_InclusionDirective) {
4173 SourceLocation L
4174 = cxcursor::getCursorInclusionDirective(C)->getSourceRange().getBegin();
4175 return cxloc::translateSourceLocation(getCursorContext(C), L);
4176 }
4177
4178 if (!clang_isDeclaration(C.kind))
4179 return clang_getNullLocation();
4180
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004181 const Decl *D = getCursorDecl(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004182 if (!D)
4183 return clang_getNullLocation();
4184
4185 SourceLocation Loc = D->getLocation();
4186 // FIXME: Multiple variables declared in a single declaration
4187 // currently lack the information needed to correctly determine their
4188 // ranges when accounting for the type-specifier. We use context
4189 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
4190 // and if so, whether it is the first decl.
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004191 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004192 if (!cxcursor::isFirstInDeclGroup(C))
4193 Loc = VD->getLocation();
4194 }
4195
4196 // For ObjC methods, give the start location of the method name.
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004197 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004198 Loc = MD->getSelectorStartLoc();
4199
4200 return cxloc::translateSourceLocation(getCursorContext(C), Loc);
4201}
4202
4203} // end extern "C"
4204
4205CXCursor cxcursor::getCursor(CXTranslationUnit TU, SourceLocation SLoc) {
4206 assert(TU);
4207
4208 // Guard against an invalid SourceLocation, or we may assert in one
4209 // of the following calls.
4210 if (SLoc.isInvalid())
4211 return clang_getNullCursor();
4212
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00004213 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004214
4215 // Translate the given source location to make it point at the beginning of
4216 // the token under the cursor.
4217 SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(),
4218 CXXUnit->getASTContext().getLangOpts());
4219
4220 CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound);
4221 if (SLoc.isValid()) {
4222 GetCursorData ResultData(CXXUnit->getSourceManager(), SLoc, Result);
4223 CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData,
4224 /*VisitPreprocessorLast=*/true,
4225 /*VisitIncludedEntities=*/false,
4226 SourceLocation(SLoc));
4227 CursorVis.visitFileRegion();
4228 }
4229
4230 return Result;
4231}
4232
4233static SourceRange getRawCursorExtent(CXCursor C) {
4234 if (clang_isReference(C.kind)) {
4235 switch (C.kind) {
4236 case CXCursor_ObjCSuperClassRef:
4237 return getCursorObjCSuperClassRef(C).second;
4238
4239 case CXCursor_ObjCProtocolRef:
4240 return getCursorObjCProtocolRef(C).second;
4241
4242 case CXCursor_ObjCClassRef:
4243 return getCursorObjCClassRef(C).second;
4244
4245 case CXCursor_TypeRef:
4246 return getCursorTypeRef(C).second;
4247
4248 case CXCursor_TemplateRef:
4249 return getCursorTemplateRef(C).second;
4250
4251 case CXCursor_NamespaceRef:
4252 return getCursorNamespaceRef(C).second;
4253
4254 case CXCursor_MemberRef:
4255 return getCursorMemberRef(C).second;
4256
4257 case CXCursor_CXXBaseSpecifier:
4258 return getCursorCXXBaseSpecifier(C)->getSourceRange();
4259
4260 case CXCursor_LabelRef:
4261 return getCursorLabelRef(C).second;
4262
4263 case CXCursor_OverloadedDeclRef:
4264 return getCursorOverloadedDeclRef(C).second;
4265
4266 case CXCursor_VariableRef:
4267 return getCursorVariableRef(C).second;
4268
4269 default:
4270 // FIXME: Need a way to enumerate all non-reference cases.
4271 llvm_unreachable("Missed a reference kind");
4272 }
4273 }
4274
4275 if (clang_isExpression(C.kind))
4276 return getCursorExpr(C)->getSourceRange();
4277
4278 if (clang_isStatement(C.kind))
4279 return getCursorStmt(C)->getSourceRange();
4280
4281 if (clang_isAttribute(C.kind))
4282 return getCursorAttr(C)->getRange();
4283
4284 if (C.kind == CXCursor_PreprocessingDirective)
4285 return cxcursor::getCursorPreprocessingDirective(C);
4286
4287 if (C.kind == CXCursor_MacroExpansion) {
4288 ASTUnit *TU = getCursorASTUnit(C);
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +00004289 SourceRange Range = cxcursor::getCursorMacroExpansion(C).getSourceRange();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004290 return TU->mapRangeFromPreamble(Range);
4291 }
4292
4293 if (C.kind == CXCursor_MacroDefinition) {
4294 ASTUnit *TU = getCursorASTUnit(C);
4295 SourceRange Range = cxcursor::getCursorMacroDefinition(C)->getSourceRange();
4296 return TU->mapRangeFromPreamble(Range);
4297 }
4298
4299 if (C.kind == CXCursor_InclusionDirective) {
4300 ASTUnit *TU = getCursorASTUnit(C);
4301 SourceRange Range = cxcursor::getCursorInclusionDirective(C)->getSourceRange();
4302 return TU->mapRangeFromPreamble(Range);
4303 }
4304
4305 if (C.kind == CXCursor_TranslationUnit) {
4306 ASTUnit *TU = getCursorASTUnit(C);
4307 FileID MainID = TU->getSourceManager().getMainFileID();
4308 SourceLocation Start = TU->getSourceManager().getLocForStartOfFile(MainID);
4309 SourceLocation End = TU->getSourceManager().getLocForEndOfFile(MainID);
4310 return SourceRange(Start, End);
4311 }
4312
4313 if (clang_isDeclaration(C.kind)) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004314 const Decl *D = cxcursor::getCursorDecl(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004315 if (!D)
4316 return SourceRange();
4317
4318 SourceRange R = D->getSourceRange();
4319 // FIXME: Multiple variables declared in a single declaration
4320 // currently lack the information needed to correctly determine their
4321 // ranges when accounting for the type-specifier. We use context
4322 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
4323 // and if so, whether it is the first decl.
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004324 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004325 if (!cxcursor::isFirstInDeclGroup(C))
4326 R.setBegin(VD->getLocation());
4327 }
4328 return R;
4329 }
4330 return SourceRange();
4331}
4332
4333/// \brief Retrieves the "raw" cursor extent, which is then extended to include
4334/// the decl-specifier-seq for declarations.
4335static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) {
4336 if (clang_isDeclaration(C.kind)) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004337 const Decl *D = cxcursor::getCursorDecl(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004338 if (!D)
4339 return SourceRange();
4340
4341 SourceRange R = D->getSourceRange();
4342
4343 // Adjust the start of the location for declarations preceded by
4344 // declaration specifiers.
4345 SourceLocation StartLoc;
4346 if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
4347 if (TypeSourceInfo *TI = DD->getTypeSourceInfo())
4348 StartLoc = TI->getTypeLoc().getLocStart();
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004349 } else if (const TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004350 if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo())
4351 StartLoc = TI->getTypeLoc().getLocStart();
4352 }
4353
4354 if (StartLoc.isValid() && R.getBegin().isValid() &&
4355 SrcMgr.isBeforeInTranslationUnit(StartLoc, R.getBegin()))
4356 R.setBegin(StartLoc);
4357
4358 // FIXME: Multiple variables declared in a single declaration
4359 // currently lack the information needed to correctly determine their
4360 // ranges when accounting for the type-specifier. We use context
4361 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
4362 // and if so, whether it is the first decl.
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004363 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004364 if (!cxcursor::isFirstInDeclGroup(C))
4365 R.setBegin(VD->getLocation());
4366 }
4367
4368 return R;
4369 }
4370
4371 return getRawCursorExtent(C);
4372}
4373
4374extern "C" {
4375
4376CXSourceRange clang_getCursorExtent(CXCursor C) {
4377 SourceRange R = getRawCursorExtent(C);
4378 if (R.isInvalid())
4379 return clang_getNullRange();
4380
4381 return cxloc::translateSourceRange(getCursorContext(C), R);
4382}
4383
4384CXCursor clang_getCursorReferenced(CXCursor C) {
4385 if (clang_isInvalid(C.kind))
4386 return clang_getNullCursor();
4387
4388 CXTranslationUnit tu = getCursorTU(C);
4389 if (clang_isDeclaration(C.kind)) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004390 const Decl *D = getCursorDecl(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004391 if (!D)
4392 return clang_getNullCursor();
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004393 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004394 return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu);
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004395 if (const ObjCPropertyImplDecl *PropImpl =
4396 dyn_cast<ObjCPropertyImplDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004397 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
4398 return MakeCXCursor(Property, tu);
4399
4400 return C;
4401 }
4402
4403 if (clang_isExpression(C.kind)) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004404 const Expr *E = getCursorExpr(C);
4405 const Decl *D = getDeclFromExpr(E);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004406 if (D) {
4407 CXCursor declCursor = MakeCXCursor(D, tu);
4408 declCursor = getSelectorIdentifierCursor(getSelectorIdentifierIndex(C),
4409 declCursor);
4410 return declCursor;
4411 }
4412
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004413 if (const OverloadExpr *Ovl = dyn_cast_or_null<OverloadExpr>(E))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004414 return MakeCursorOverloadedDeclRef(Ovl, tu);
4415
4416 return clang_getNullCursor();
4417 }
4418
4419 if (clang_isStatement(C.kind)) {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00004420 const Stmt *S = getCursorStmt(C);
4421 if (const GotoStmt *Goto = dyn_cast_or_null<GotoStmt>(S))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004422 if (LabelDecl *label = Goto->getLabel())
4423 if (LabelStmt *labelS = label->getStmt())
4424 return MakeCXCursor(labelS, getCursorDecl(C), tu);
4425
4426 return clang_getNullCursor();
4427 }
4428
4429 if (C.kind == CXCursor_MacroExpansion) {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004430 if (const MacroDefinition *Def = getCursorMacroExpansion(C).getDefinition())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004431 return MakeMacroDefinitionCursor(Def, tu);
4432 }
4433
4434 if (!clang_isReference(C.kind))
4435 return clang_getNullCursor();
4436
4437 switch (C.kind) {
4438 case CXCursor_ObjCSuperClassRef:
4439 return MakeCXCursor(getCursorObjCSuperClassRef(C).first, tu);
4440
4441 case CXCursor_ObjCProtocolRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004442 const ObjCProtocolDecl *Prot = getCursorObjCProtocolRef(C).first;
4443 if (const ObjCProtocolDecl *Def = Prot->getDefinition())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004444 return MakeCXCursor(Def, tu);
4445
4446 return MakeCXCursor(Prot, tu);
4447 }
4448
4449 case CXCursor_ObjCClassRef: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004450 const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
4451 if (const ObjCInterfaceDecl *Def = Class->getDefinition())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004452 return MakeCXCursor(Def, tu);
4453
4454 return MakeCXCursor(Class, tu);
4455 }
4456
4457 case CXCursor_TypeRef:
4458 return MakeCXCursor(getCursorTypeRef(C).first, tu );
4459
4460 case CXCursor_TemplateRef:
4461 return MakeCXCursor(getCursorTemplateRef(C).first, tu );
4462
4463 case CXCursor_NamespaceRef:
4464 return MakeCXCursor(getCursorNamespaceRef(C).first, tu );
4465
4466 case CXCursor_MemberRef:
4467 return MakeCXCursor(getCursorMemberRef(C).first, tu );
4468
4469 case CXCursor_CXXBaseSpecifier: {
Dmitri Gribenko67812b22013-01-11 21:01:49 +00004470 const CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004471 return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(),
4472 tu ));
4473 }
4474
4475 case CXCursor_LabelRef:
4476 // FIXME: We end up faking the "parent" declaration here because we
4477 // don't want to make CXCursor larger.
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00004478 return MakeCXCursor(getCursorLabelRef(C).first,
4479 cxtu::getASTUnit(tu)->getASTContext()
4480 .getTranslationUnitDecl(),
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004481 tu);
4482
4483 case CXCursor_OverloadedDeclRef:
4484 return C;
4485
4486 case CXCursor_VariableRef:
4487 return MakeCXCursor(getCursorVariableRef(C).first, tu);
4488
4489 default:
4490 // We would prefer to enumerate all non-reference cursor kinds here.
4491 llvm_unreachable("Unhandled reference cursor kind");
4492 }
4493}
4494
4495CXCursor clang_getCursorDefinition(CXCursor C) {
4496 if (clang_isInvalid(C.kind))
4497 return clang_getNullCursor();
4498
4499 CXTranslationUnit TU = getCursorTU(C);
4500
4501 bool WasReference = false;
4502 if (clang_isReference(C.kind) || clang_isExpression(C.kind)) {
4503 C = clang_getCursorReferenced(C);
4504 WasReference = true;
4505 }
4506
4507 if (C.kind == CXCursor_MacroExpansion)
4508 return clang_getCursorReferenced(C);
4509
4510 if (!clang_isDeclaration(C.kind))
4511 return clang_getNullCursor();
4512
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004513 const Decl *D = getCursorDecl(C);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004514 if (!D)
4515 return clang_getNullCursor();
4516
4517 switch (D->getKind()) {
4518 // Declaration kinds that don't really separate the notions of
4519 // declaration and definition.
4520 case Decl::Namespace:
4521 case Decl::Typedef:
4522 case Decl::TypeAlias:
4523 case Decl::TypeAliasTemplate:
4524 case Decl::TemplateTypeParm:
4525 case Decl::EnumConstant:
4526 case Decl::Field:
John McCall76da55d2013-04-16 07:28:30 +00004527 case Decl::MSProperty:
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004528 case Decl::IndirectField:
4529 case Decl::ObjCIvar:
4530 case Decl::ObjCAtDefsField:
4531 case Decl::ImplicitParam:
4532 case Decl::ParmVar:
4533 case Decl::NonTypeTemplateParm:
4534 case Decl::TemplateTemplateParm:
4535 case Decl::ObjCCategoryImpl:
4536 case Decl::ObjCImplementation:
4537 case Decl::AccessSpec:
4538 case Decl::LinkageSpec:
4539 case Decl::ObjCPropertyImpl:
4540 case Decl::FileScopeAsm:
4541 case Decl::StaticAssert:
4542 case Decl::Block:
Tareq A. Siraj6afcf882013-04-16 19:37:38 +00004543 case Decl::Captured:
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004544 case Decl::Label: // FIXME: Is this right??
4545 case Decl::ClassScopeFunctionSpecialization:
4546 case Decl::Import:
Alexey Bataevc6400582013-03-22 06:34:35 +00004547 case Decl::OMPThreadPrivate:
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004548 return C;
4549
4550 // Declaration kinds that don't make any sense here, but are
4551 // nonetheless harmless.
David Blaikief23546a2013-02-22 17:44:58 +00004552 case Decl::Empty:
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004553 case Decl::TranslationUnit:
4554 break;
4555
4556 // Declaration kinds for which the definition is not resolvable.
4557 case Decl::UnresolvedUsingTypename:
4558 case Decl::UnresolvedUsingValue:
4559 break;
4560
4561 case Decl::UsingDirective:
4562 return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(),
4563 TU);
4564
4565 case Decl::NamespaceAlias:
4566 return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), TU);
4567
4568 case Decl::Enum:
4569 case Decl::Record:
4570 case Decl::CXXRecord:
4571 case Decl::ClassTemplateSpecialization:
4572 case Decl::ClassTemplatePartialSpecialization:
4573 if (TagDecl *Def = cast<TagDecl>(D)->getDefinition())
4574 return MakeCXCursor(Def, TU);
4575 return clang_getNullCursor();
4576
4577 case Decl::Function:
4578 case Decl::CXXMethod:
4579 case Decl::CXXConstructor:
4580 case Decl::CXXDestructor:
4581 case Decl::CXXConversion: {
4582 const FunctionDecl *Def = 0;
4583 if (cast<FunctionDecl>(D)->getBody(Def))
Dmitri Gribenko05756dc2013-01-14 00:46:27 +00004584 return MakeCXCursor(Def, TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004585 return clang_getNullCursor();
4586 }
4587
4588 case Decl::Var: {
4589 // Ask the variable if it has a definition.
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004590 if (const VarDecl *Def = cast<VarDecl>(D)->getDefinition())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004591 return MakeCXCursor(Def, TU);
4592 return clang_getNullCursor();
4593 }
4594
4595 case Decl::FunctionTemplate: {
4596 const FunctionDecl *Def = 0;
4597 if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def))
4598 return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU);
4599 return clang_getNullCursor();
4600 }
4601
4602 case Decl::ClassTemplate: {
4603 if (RecordDecl *Def = cast<ClassTemplateDecl>(D)->getTemplatedDecl()
4604 ->getDefinition())
4605 return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(),
4606 TU);
4607 return clang_getNullCursor();
4608 }
4609
4610 case Decl::Using:
4611 return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D),
4612 D->getLocation(), TU);
4613
4614 case Decl::UsingShadow:
4615 return clang_getCursorDefinition(
4616 MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(),
4617 TU));
4618
4619 case Decl::ObjCMethod: {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004620 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004621 if (Method->isThisDeclarationADefinition())
4622 return C;
4623
4624 // Dig out the method definition in the associated
4625 // @implementation, if we have it.
4626 // FIXME: The ASTs should make finding the definition easier.
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004627 if (const ObjCInterfaceDecl *Class
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004628 = dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext()))
4629 if (ObjCImplementationDecl *ClassImpl = Class->getImplementation())
4630 if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(),
4631 Method->isInstanceMethod()))
4632 if (Def->isThisDeclarationADefinition())
4633 return MakeCXCursor(Def, TU);
4634
4635 return clang_getNullCursor();
4636 }
4637
4638 case Decl::ObjCCategory:
4639 if (ObjCCategoryImplDecl *Impl
4640 = cast<ObjCCategoryDecl>(D)->getImplementation())
4641 return MakeCXCursor(Impl, TU);
4642 return clang_getNullCursor();
4643
4644 case Decl::ObjCProtocol:
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004645 if (const ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(D)->getDefinition())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004646 return MakeCXCursor(Def, TU);
4647 return clang_getNullCursor();
4648
4649 case Decl::ObjCInterface: {
4650 // There are two notions of a "definition" for an Objective-C
4651 // class: the interface and its implementation. When we resolved a
4652 // reference to an Objective-C class, produce the @interface as
4653 // the definition; when we were provided with the interface,
4654 // produce the @implementation as the definition.
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004655 const ObjCInterfaceDecl *IFace = cast<ObjCInterfaceDecl>(D);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004656 if (WasReference) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004657 if (const ObjCInterfaceDecl *Def = IFace->getDefinition())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004658 return MakeCXCursor(Def, TU);
4659 } else if (ObjCImplementationDecl *Impl = IFace->getImplementation())
4660 return MakeCXCursor(Impl, TU);
4661 return clang_getNullCursor();
4662 }
4663
4664 case Decl::ObjCProperty:
4665 // FIXME: We don't really know where to find the
4666 // ObjCPropertyImplDecls that implement this property.
4667 return clang_getNullCursor();
4668
4669 case Decl::ObjCCompatibleAlias:
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004670 if (const ObjCInterfaceDecl *Class
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004671 = cast<ObjCCompatibleAliasDecl>(D)->getClassInterface())
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004672 if (const ObjCInterfaceDecl *Def = Class->getDefinition())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004673 return MakeCXCursor(Def, TU);
4674
4675 return clang_getNullCursor();
4676
4677 case Decl::Friend:
4678 if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl())
4679 return clang_getCursorDefinition(MakeCXCursor(Friend, TU));
4680 return clang_getNullCursor();
4681
4682 case Decl::FriendTemplate:
4683 if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl())
4684 return clang_getCursorDefinition(MakeCXCursor(Friend, TU));
4685 return clang_getNullCursor();
4686 }
4687
4688 return clang_getNullCursor();
4689}
4690
4691unsigned clang_isCursorDefinition(CXCursor C) {
4692 if (!clang_isDeclaration(C.kind))
4693 return 0;
4694
4695 return clang_getCursorDefinition(C) == C;
4696}
4697
4698CXCursor clang_getCanonicalCursor(CXCursor C) {
4699 if (!clang_isDeclaration(C.kind))
4700 return C;
4701
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004702 if (const Decl *D = getCursorDecl(C)) {
4703 if (const ObjCCategoryImplDecl *CatImplD = dyn_cast<ObjCCategoryImplDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004704 if (ObjCCategoryDecl *CatD = CatImplD->getCategoryDecl())
4705 return MakeCXCursor(CatD, getCursorTU(C));
4706
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004707 if (const ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
4708 if (const ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004709 return MakeCXCursor(IFD, getCursorTU(C));
4710
4711 return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C));
4712 }
4713
4714 return C;
4715}
4716
4717int clang_Cursor_getObjCSelectorIndex(CXCursor cursor) {
4718 return cxcursor::getSelectorIdentifierIndexAndLoc(cursor).first;
4719}
4720
4721unsigned clang_getNumOverloadedDecls(CXCursor C) {
4722 if (C.kind != CXCursor_OverloadedDeclRef)
4723 return 0;
4724
4725 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004726 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004727 return E->getNumDecls();
4728
4729 if (OverloadedTemplateStorage *S
4730 = Storage.dyn_cast<OverloadedTemplateStorage*>())
4731 return S->size();
4732
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004733 const Decl *D = Storage.get<const Decl *>();
4734 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004735 return Using->shadow_size();
4736
4737 return 0;
4738}
4739
4740CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) {
4741 if (cursor.kind != CXCursor_OverloadedDeclRef)
4742 return clang_getNullCursor();
4743
4744 if (index >= clang_getNumOverloadedDecls(cursor))
4745 return clang_getNullCursor();
4746
4747 CXTranslationUnit TU = getCursorTU(cursor);
4748 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first;
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004749 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004750 return MakeCXCursor(E->decls_begin()[index], TU);
4751
4752 if (OverloadedTemplateStorage *S
4753 = Storage.dyn_cast<OverloadedTemplateStorage*>())
4754 return MakeCXCursor(S->begin()[index], TU);
4755
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004756 const Decl *D = Storage.get<const Decl *>();
4757 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004758 // FIXME: This is, unfortunately, linear time.
4759 UsingDecl::shadow_iterator Pos = Using->shadow_begin();
4760 std::advance(Pos, index);
4761 return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU);
4762 }
4763
4764 return clang_getNullCursor();
4765}
4766
4767void clang_getDefinitionSpellingAndExtent(CXCursor C,
4768 const char **startBuf,
4769 const char **endBuf,
4770 unsigned *startLine,
4771 unsigned *startColumn,
4772 unsigned *endLine,
4773 unsigned *endColumn) {
4774 assert(getCursorDecl(C) && "CXCursor has null decl");
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00004775 const FunctionDecl *FD = dyn_cast<FunctionDecl>(getCursorDecl(C));
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004776 CompoundStmt *Body = dyn_cast<CompoundStmt>(FD->getBody());
4777
4778 SourceManager &SM = FD->getASTContext().getSourceManager();
4779 *startBuf = SM.getCharacterData(Body->getLBracLoc());
4780 *endBuf = SM.getCharacterData(Body->getRBracLoc());
4781 *startLine = SM.getSpellingLineNumber(Body->getLBracLoc());
4782 *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc());
4783 *endLine = SM.getSpellingLineNumber(Body->getRBracLoc());
4784 *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc());
4785}
4786
4787
4788CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags,
4789 unsigned PieceIndex) {
4790 RefNamePieces Pieces;
4791
4792 switch (C.kind) {
4793 case CXCursor_MemberRefExpr:
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00004794 if (const MemberExpr *E = dyn_cast<MemberExpr>(getCursorExpr(C)))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004795 Pieces = buildPieces(NameFlags, true, E->getMemberNameInfo(),
4796 E->getQualifierLoc().getSourceRange());
4797 break;
4798
4799 case CXCursor_DeclRefExpr:
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00004800 if (const DeclRefExpr *E = dyn_cast<DeclRefExpr>(getCursorExpr(C)))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004801 Pieces = buildPieces(NameFlags, false, E->getNameInfo(),
4802 E->getQualifierLoc().getSourceRange(),
4803 E->getOptionalExplicitTemplateArgs());
4804 break;
4805
4806 case CXCursor_CallExpr:
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00004807 if (const CXXOperatorCallExpr *OCE =
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004808 dyn_cast<CXXOperatorCallExpr>(getCursorExpr(C))) {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00004809 const Expr *Callee = OCE->getCallee();
4810 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004811 Callee = ICE->getSubExpr();
4812
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00004813 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004814 Pieces = buildPieces(NameFlags, false, DRE->getNameInfo(),
4815 DRE->getQualifierLoc().getSourceRange());
4816 }
4817 break;
4818
4819 default:
4820 break;
4821 }
4822
4823 if (Pieces.empty()) {
4824 if (PieceIndex == 0)
4825 return clang_getCursorExtent(C);
4826 } else if (PieceIndex < Pieces.size()) {
4827 SourceRange R = Pieces[PieceIndex];
4828 if (R.isValid())
4829 return cxloc::translateSourceRange(getCursorContext(C), R);
4830 }
4831
4832 return clang_getNullRange();
4833}
4834
4835void clang_enableStackTraces(void) {
4836 llvm::sys::PrintStackTraceOnErrorSignal();
4837}
4838
4839void clang_executeOnThread(void (*fn)(void*), void *user_data,
4840 unsigned stack_size) {
4841 llvm::llvm_execute_on_thread(fn, user_data, stack_size);
4842}
4843
4844} // end: extern "C"
4845
4846//===----------------------------------------------------------------------===//
4847// Token-based Operations.
4848//===----------------------------------------------------------------------===//
4849
4850/* CXToken layout:
4851 * int_data[0]: a CXTokenKind
4852 * int_data[1]: starting token location
4853 * int_data[2]: token length
4854 * int_data[3]: reserved
4855 * ptr_data: for identifiers and keywords, an IdentifierInfo*.
4856 * otherwise unused.
4857 */
4858extern "C" {
4859
4860CXTokenKind clang_getTokenKind(CXToken CXTok) {
4861 return static_cast<CXTokenKind>(CXTok.int_data[0]);
4862}
4863
4864CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) {
4865 switch (clang_getTokenKind(CXTok)) {
4866 case CXToken_Identifier:
4867 case CXToken_Keyword:
4868 // We know we have an IdentifierInfo*, so use that.
Dmitri Gribenko0c4394c2013-02-02 00:02:12 +00004869 return cxstring::createRef(static_cast<IdentifierInfo *>(CXTok.ptr_data)
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004870 ->getNameStart());
4871
4872 case CXToken_Literal: {
4873 // We have stashed the starting pointer in the ptr_data field. Use it.
4874 const char *Text = static_cast<const char *>(CXTok.ptr_data);
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00004875 return cxstring::createDup(StringRef(Text, CXTok.int_data[2]));
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004876 }
4877
4878 case CXToken_Punctuation:
4879 case CXToken_Comment:
4880 break;
4881 }
4882
4883 // We have to find the starting buffer pointer the hard way, by
4884 // deconstructing the source location.
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00004885 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004886 if (!CXXUnit)
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00004887 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004888
4889 SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]);
4890 std::pair<FileID, unsigned> LocInfo
4891 = CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc);
4892 bool Invalid = false;
4893 StringRef Buffer
4894 = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid);
4895 if (Invalid)
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00004896 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004897
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00004898 return cxstring::createDup(Buffer.substr(LocInfo.second, CXTok.int_data[2]));
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004899}
4900
4901CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) {
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00004902 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004903 if (!CXXUnit)
4904 return clang_getNullLocation();
4905
4906 return cxloc::translateSourceLocation(CXXUnit->getASTContext(),
4907 SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
4908}
4909
4910CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) {
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00004911 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004912 if (!CXXUnit)
4913 return clang_getNullRange();
4914
4915 return cxloc::translateSourceRange(CXXUnit->getASTContext(),
4916 SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
4917}
4918
4919static void getTokens(ASTUnit *CXXUnit, SourceRange Range,
4920 SmallVectorImpl<CXToken> &CXTokens) {
4921 SourceManager &SourceMgr = CXXUnit->getSourceManager();
4922 std::pair<FileID, unsigned> BeginLocInfo
Argyrios Kyrtzidis82064212013-02-13 18:33:28 +00004923 = SourceMgr.getDecomposedSpellingLoc(Range.getBegin());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004924 std::pair<FileID, unsigned> EndLocInfo
Argyrios Kyrtzidis82064212013-02-13 18:33:28 +00004925 = SourceMgr.getDecomposedSpellingLoc(Range.getEnd());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004926
4927 // Cannot tokenize across files.
4928 if (BeginLocInfo.first != EndLocInfo.first)
4929 return;
4930
4931 // Create a lexer
4932 bool Invalid = false;
4933 StringRef Buffer
4934 = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
4935 if (Invalid)
4936 return;
4937
4938 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
4939 CXXUnit->getASTContext().getLangOpts(),
4940 Buffer.begin(), Buffer.data() + BeginLocInfo.second, Buffer.end());
4941 Lex.SetCommentRetentionState(true);
4942
4943 // Lex tokens until we hit the end of the range.
4944 const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second;
4945 Token Tok;
4946 bool previousWasAt = false;
4947 do {
4948 // Lex the next token
4949 Lex.LexFromRawLexer(Tok);
4950 if (Tok.is(tok::eof))
4951 break;
4952
4953 // Initialize the CXToken.
4954 CXToken CXTok;
4955
4956 // - Common fields
4957 CXTok.int_data[1] = Tok.getLocation().getRawEncoding();
4958 CXTok.int_data[2] = Tok.getLength();
4959 CXTok.int_data[3] = 0;
4960
4961 // - Kind-specific fields
4962 if (Tok.isLiteral()) {
4963 CXTok.int_data[0] = CXToken_Literal;
Dmitri Gribenkoe4ea8792013-01-23 15:56:07 +00004964 CXTok.ptr_data = const_cast<char *>(Tok.getLiteralData());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004965 } else if (Tok.is(tok::raw_identifier)) {
4966 // Lookup the identifier to determine whether we have a keyword.
4967 IdentifierInfo *II
4968 = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok);
4969
4970 if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) {
4971 CXTok.int_data[0] = CXToken_Keyword;
4972 }
4973 else {
4974 CXTok.int_data[0] = Tok.is(tok::identifier)
4975 ? CXToken_Identifier
4976 : CXToken_Keyword;
4977 }
4978 CXTok.ptr_data = II;
4979 } else if (Tok.is(tok::comment)) {
4980 CXTok.int_data[0] = CXToken_Comment;
4981 CXTok.ptr_data = 0;
4982 } else {
4983 CXTok.int_data[0] = CXToken_Punctuation;
4984 CXTok.ptr_data = 0;
4985 }
4986 CXTokens.push_back(CXTok);
4987 previousWasAt = Tok.is(tok::at);
4988 } while (Lex.getBufferLocation() <= EffectiveBufferEnd);
4989}
4990
4991void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range,
4992 CXToken **Tokens, unsigned *NumTokens) {
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00004993 LOG_FUNC_SECTION {
4994 *Log << TU << ' ' << Range;
4995 }
4996
Guy Benyei7f92f2d2012-12-18 14:30:41 +00004997 if (Tokens)
4998 *Tokens = 0;
4999 if (NumTokens)
5000 *NumTokens = 0;
5001
Argyrios Kyrtzidis0b602832013-04-04 22:40:59 +00005002 if (!TU)
5003 return;
5004
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00005005 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005006 if (!CXXUnit || !Tokens || !NumTokens)
5007 return;
5008
5009 ASTUnit::ConcurrencyCheck Check(*CXXUnit);
5010
5011 SourceRange R = cxloc::translateCXSourceRange(Range);
5012 if (R.isInvalid())
5013 return;
5014
5015 SmallVector<CXToken, 32> CXTokens;
5016 getTokens(CXXUnit, R, CXTokens);
5017
5018 if (CXTokens.empty())
5019 return;
5020
5021 *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size());
5022 memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size());
5023 *NumTokens = CXTokens.size();
5024}
5025
5026void clang_disposeTokens(CXTranslationUnit TU,
5027 CXToken *Tokens, unsigned NumTokens) {
5028 free(Tokens);
5029}
5030
5031} // end: extern "C"
5032
5033//===----------------------------------------------------------------------===//
5034// Token annotation APIs.
5035//===----------------------------------------------------------------------===//
5036
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005037static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
5038 CXCursor parent,
5039 CXClientData client_data);
5040static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor,
5041 CXClientData client_data);
5042
5043namespace {
5044class AnnotateTokensWorker {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005045 CXToken *Tokens;
5046 CXCursor *Cursors;
5047 unsigned NumTokens;
5048 unsigned TokIdx;
5049 unsigned PreprocessingTokIdx;
5050 CursorVisitor AnnotateVis;
5051 SourceManager &SrcMgr;
5052 bool HasContextSensitiveKeywords;
5053
5054 struct PostChildrenInfo {
5055 CXCursor Cursor;
5056 SourceRange CursorRange;
Argyrios Kyrtzidisa86b37e2013-02-08 01:12:25 +00005057 unsigned BeforeReachingCursorIdx;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005058 unsigned BeforeChildrenTokenIdx;
5059 };
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00005060 SmallVector<PostChildrenInfo, 8> PostChildrenInfos;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005061
5062 bool MoreTokens() const { return TokIdx < NumTokens; }
5063 unsigned NextToken() const { return TokIdx; }
5064 void AdvanceToken() { ++TokIdx; }
5065 SourceLocation GetTokenLoc(unsigned tokI) {
5066 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]);
5067 }
5068 bool isFunctionMacroToken(unsigned tokI) const {
5069 return Tokens[tokI].int_data[3] != 0;
5070 }
5071 SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const {
5072 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[3]);
5073 }
5074
5075 void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange);
Argyrios Kyrtzidisa86b37e2013-02-08 01:12:25 +00005076 bool annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult,
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005077 SourceRange);
5078
5079public:
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005080 AnnotateTokensWorker(CXToken *tokens, CXCursor *cursors, unsigned numTokens,
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00005081 CXTranslationUnit TU, SourceRange RegionOfInterest)
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005082 : Tokens(tokens), Cursors(cursors),
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005083 NumTokens(numTokens), TokIdx(0), PreprocessingTokIdx(0),
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00005084 AnnotateVis(TU,
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005085 AnnotateTokensVisitor, this,
5086 /*VisitPreprocessorLast=*/true,
5087 /*VisitIncludedEntities=*/false,
5088 RegionOfInterest,
5089 /*VisitDeclsOnly=*/false,
5090 AnnotateTokensPostChildrenVisitor),
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00005091 SrcMgr(cxtu::getASTUnit(TU)->getSourceManager()),
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005092 HasContextSensitiveKeywords(false) { }
5093
5094 void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); }
5095 enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent);
5096 bool postVisitChildren(CXCursor cursor);
5097 void AnnotateTokens();
5098
5099 /// \brief Determine whether the annotator saw any cursors that have
5100 /// context-sensitive keywords.
5101 bool hasContextSensitiveKeywords() const {
5102 return HasContextSensitiveKeywords;
5103 }
5104
5105 ~AnnotateTokensWorker() {
5106 assert(PostChildrenInfos.empty());
5107 }
5108};
5109}
5110
5111void AnnotateTokensWorker::AnnotateTokens() {
5112 // Walk the AST within the region of interest, annotating tokens
5113 // along the way.
5114 AnnotateVis.visitFileRegion();
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005115}
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005116
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005117static inline void updateCursorAnnotation(CXCursor &Cursor,
5118 const CXCursor &updateC) {
Argyrios Kyrtzidisa86b37e2013-02-08 01:12:25 +00005119 if (clang_isInvalid(updateC.kind) || !clang_isInvalid(Cursor.kind))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005120 return;
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005121 Cursor = updateC;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005122}
5123
5124/// \brief It annotates and advances tokens with a cursor until the comparison
5125//// between the cursor location and the source range is the same as
5126/// \arg compResult.
5127///
5128/// Pass RangeBefore to annotate tokens with a cursor until a range is reached.
5129/// Pass RangeOverlap to annotate tokens inside a range.
5130void AnnotateTokensWorker::annotateAndAdvanceTokens(CXCursor updateC,
5131 RangeComparisonResult compResult,
5132 SourceRange range) {
5133 while (MoreTokens()) {
5134 const unsigned I = NextToken();
5135 if (isFunctionMacroToken(I))
Argyrios Kyrtzidisa86b37e2013-02-08 01:12:25 +00005136 if (!annotateAndAdvanceFunctionMacroTokens(updateC, compResult, range))
5137 return;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005138
5139 SourceLocation TokLoc = GetTokenLoc(I);
5140 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) {
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005141 updateCursorAnnotation(Cursors[I], updateC);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005142 AdvanceToken();
5143 continue;
5144 }
5145 break;
5146 }
5147}
5148
5149/// \brief Special annotation handling for macro argument tokens.
Argyrios Kyrtzidisa86b37e2013-02-08 01:12:25 +00005150/// \returns true if it advanced beyond all macro tokens, false otherwise.
5151bool AnnotateTokensWorker::annotateAndAdvanceFunctionMacroTokens(
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005152 CXCursor updateC,
5153 RangeComparisonResult compResult,
5154 SourceRange range) {
5155 assert(MoreTokens());
5156 assert(isFunctionMacroToken(NextToken()) &&
5157 "Should be called only for macro arg tokens");
5158
5159 // This works differently than annotateAndAdvanceTokens; because expanded
5160 // macro arguments can have arbitrary translation-unit source order, we do not
5161 // advance the token index one by one until a token fails the range test.
5162 // We only advance once past all of the macro arg tokens if all of them
5163 // pass the range test. If one of them fails we keep the token index pointing
5164 // at the start of the macro arg tokens so that the failing token will be
5165 // annotated by a subsequent annotation try.
5166
5167 bool atLeastOneCompFail = false;
5168
5169 unsigned I = NextToken();
5170 for (; I < NumTokens && isFunctionMacroToken(I); ++I) {
5171 SourceLocation TokLoc = getFunctionMacroTokenLoc(I);
5172 if (TokLoc.isFileID())
5173 continue; // not macro arg token, it's parens or comma.
5174 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) {
5175 if (clang_isInvalid(clang_getCursorKind(Cursors[I])))
5176 Cursors[I] = updateC;
5177 } else
5178 atLeastOneCompFail = true;
5179 }
5180
Argyrios Kyrtzidisa86b37e2013-02-08 01:12:25 +00005181 if (atLeastOneCompFail)
5182 return false;
5183
5184 TokIdx = I; // All of the tokens were handled, advance beyond all of them.
5185 return true;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005186}
5187
5188enum CXChildVisitResult
5189AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005190 SourceRange cursorRange = getRawCursorExtent(cursor);
5191 if (cursorRange.isInvalid())
5192 return CXChildVisit_Recurse;
5193
5194 if (!HasContextSensitiveKeywords) {
5195 // Objective-C properties can have context-sensitive keywords.
5196 if (cursor.kind == CXCursor_ObjCPropertyDecl) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005197 if (const ObjCPropertyDecl *Property
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005198 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(cursor)))
5199 HasContextSensitiveKeywords = Property->getPropertyAttributesAsWritten() != 0;
5200 }
5201 // Objective-C methods can have context-sensitive keywords.
5202 else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl ||
5203 cursor.kind == CXCursor_ObjCClassMethodDecl) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005204 if (const ObjCMethodDecl *Method
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005205 = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) {
5206 if (Method->getObjCDeclQualifier())
5207 HasContextSensitiveKeywords = true;
5208 else {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005209 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
5210 PEnd = Method->param_end();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005211 P != PEnd; ++P) {
5212 if ((*P)->getObjCDeclQualifier()) {
5213 HasContextSensitiveKeywords = true;
5214 break;
5215 }
5216 }
5217 }
5218 }
5219 }
5220 // C++ methods can have context-sensitive keywords.
5221 else if (cursor.kind == CXCursor_CXXMethod) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005222 if (const CXXMethodDecl *Method
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005223 = dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(cursor))) {
5224 if (Method->hasAttr<FinalAttr>() || Method->hasAttr<OverrideAttr>())
5225 HasContextSensitiveKeywords = true;
5226 }
5227 }
5228 // C++ classes can have context-sensitive keywords.
5229 else if (cursor.kind == CXCursor_StructDecl ||
5230 cursor.kind == CXCursor_ClassDecl ||
5231 cursor.kind == CXCursor_ClassTemplate ||
5232 cursor.kind == CXCursor_ClassTemplatePartialSpecialization) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005233 if (const Decl *D = getCursorDecl(cursor))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005234 if (D->hasAttr<FinalAttr>())
5235 HasContextSensitiveKeywords = true;
5236 }
5237 }
Argyrios Kyrtzidis25cd4a22013-06-04 18:24:30 +00005238
5239 // Don't override a property annotation with its getter/setter method.
5240 if (cursor.kind == CXCursor_ObjCInstanceMethodDecl &&
5241 parent.kind == CXCursor_ObjCPropertyDecl)
5242 return CXChildVisit_Continue;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005243
5244 if (clang_isPreprocessing(cursor.kind)) {
5245 // Items in the preprocessing record are kept separate from items in
5246 // declarations, so we keep a separate token index.
5247 unsigned SavedTokIdx = TokIdx;
5248 TokIdx = PreprocessingTokIdx;
5249
5250 // Skip tokens up until we catch up to the beginning of the preprocessing
5251 // entry.
5252 while (MoreTokens()) {
5253 const unsigned I = NextToken();
5254 SourceLocation TokLoc = GetTokenLoc(I);
5255 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
5256 case RangeBefore:
5257 AdvanceToken();
5258 continue;
5259 case RangeAfter:
5260 case RangeOverlap:
5261 break;
5262 }
5263 break;
5264 }
5265
5266 // Look at all of the tokens within this range.
5267 while (MoreTokens()) {
5268 const unsigned I = NextToken();
5269 SourceLocation TokLoc = GetTokenLoc(I);
5270 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
5271 case RangeBefore:
5272 llvm_unreachable("Infeasible");
5273 case RangeAfter:
5274 break;
5275 case RangeOverlap:
Argyrios Kyrtzidis82064212013-02-13 18:33:28 +00005276 // For macro expansions, just note where the beginning of the macro
5277 // expansion occurs.
5278 if (cursor.kind == CXCursor_MacroExpansion) {
5279 if (TokLoc == cursorRange.getBegin())
5280 Cursors[I] = cursor;
5281 AdvanceToken();
5282 break;
5283 }
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005284 // We may have already annotated macro names inside macro definitions.
5285 if (Cursors[I].kind != CXCursor_MacroExpansion)
5286 Cursors[I] = cursor;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005287 AdvanceToken();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005288 continue;
5289 }
5290 break;
5291 }
5292
5293 // Save the preprocessing token index; restore the non-preprocessing
5294 // token index.
5295 PreprocessingTokIdx = TokIdx;
5296 TokIdx = SavedTokIdx;
5297 return CXChildVisit_Recurse;
5298 }
5299
5300 if (cursorRange.isInvalid())
5301 return CXChildVisit_Continue;
Argyrios Kyrtzidisa86b37e2013-02-08 01:12:25 +00005302
5303 unsigned BeforeReachingCursorIdx = NextToken();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005304 const enum CXCursorKind cursorK = clang_getCursorKind(cursor);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005305 const enum CXCursorKind K = clang_getCursorKind(parent);
5306 const CXCursor updateC =
Argyrios Kyrtzidisa86b37e2013-02-08 01:12:25 +00005307 (clang_isInvalid(K) || K == CXCursor_TranslationUnit ||
5308 // Attributes are annotated out-of-order, skip tokens until we reach it.
5309 clang_isAttribute(cursor.kind))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005310 ? clang_getNullCursor() : parent;
5311
5312 annotateAndAdvanceTokens(updateC, RangeBefore, cursorRange);
5313
5314 // Avoid having the cursor of an expression "overwrite" the annotation of the
5315 // variable declaration that it belongs to.
5316 // This can happen for C++ constructor expressions whose range generally
5317 // include the variable declaration, e.g.:
5318 // MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor.
5319 if (clang_isExpression(cursorK)) {
Dmitri Gribenkoff74f962013-01-26 15:29:08 +00005320 const Expr *E = getCursorExpr(cursor);
Dmitri Gribenko404628c2013-01-26 18:12:08 +00005321 if (const Decl *D = getCursorParentDecl(cursor)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005322 const unsigned I = NextToken();
5323 if (E->getLocStart().isValid() && D->getLocation().isValid() &&
5324 E->getLocStart() == D->getLocation() &&
5325 E->getLocStart() == GetTokenLoc(I)) {
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005326 updateCursorAnnotation(Cursors[I], updateC);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005327 AdvanceToken();
5328 }
5329 }
5330 }
5331
5332 // Before recursing into the children keep some state that we are going
5333 // to use in the AnnotateTokensWorker::postVisitChildren callback to do some
5334 // extra work after the child nodes are visited.
5335 // Note that we don't call VisitChildren here to avoid traversing statements
5336 // code-recursively which can blow the stack.
5337
5338 PostChildrenInfo Info;
5339 Info.Cursor = cursor;
5340 Info.CursorRange = cursorRange;
Argyrios Kyrtzidisa86b37e2013-02-08 01:12:25 +00005341 Info.BeforeReachingCursorIdx = BeforeReachingCursorIdx;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005342 Info.BeforeChildrenTokenIdx = NextToken();
5343 PostChildrenInfos.push_back(Info);
5344
5345 return CXChildVisit_Recurse;
5346}
5347
5348bool AnnotateTokensWorker::postVisitChildren(CXCursor cursor) {
5349 if (PostChildrenInfos.empty())
5350 return false;
5351 const PostChildrenInfo &Info = PostChildrenInfos.back();
5352 if (!clang_equalCursors(Info.Cursor, cursor))
5353 return false;
5354
5355 const unsigned BeforeChildren = Info.BeforeChildrenTokenIdx;
5356 const unsigned AfterChildren = NextToken();
5357 SourceRange cursorRange = Info.CursorRange;
5358
5359 // Scan the tokens that are at the end of the cursor, but are not captured
5360 // but the child cursors.
5361 annotateAndAdvanceTokens(cursor, RangeOverlap, cursorRange);
5362
5363 // Scan the tokens that are at the beginning of the cursor, but are not
5364 // capture by the child cursors.
5365 for (unsigned I = BeforeChildren; I != AfterChildren; ++I) {
5366 if (!clang_isInvalid(clang_getCursorKind(Cursors[I])))
5367 break;
5368
5369 Cursors[I] = cursor;
5370 }
5371
Argyrios Kyrtzidisa86b37e2013-02-08 01:12:25 +00005372 // Attributes are annotated out-of-order, rewind TokIdx to when we first
5373 // encountered the attribute cursor.
5374 if (clang_isAttribute(cursor.kind))
5375 TokIdx = Info.BeforeReachingCursorIdx;
5376
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005377 PostChildrenInfos.pop_back();
5378 return false;
5379}
5380
5381static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
5382 CXCursor parent,
5383 CXClientData client_data) {
5384 return static_cast<AnnotateTokensWorker*>(client_data)->Visit(cursor, parent);
5385}
5386
5387static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor,
5388 CXClientData client_data) {
5389 return static_cast<AnnotateTokensWorker*>(client_data)->
5390 postVisitChildren(cursor);
5391}
5392
5393namespace {
5394
5395/// \brief Uses the macro expansions in the preprocessing record to find
5396/// and mark tokens that are macro arguments. This info is used by the
5397/// AnnotateTokensWorker.
5398class MarkMacroArgTokensVisitor {
5399 SourceManager &SM;
5400 CXToken *Tokens;
5401 unsigned NumTokens;
5402 unsigned CurIdx;
5403
5404public:
5405 MarkMacroArgTokensVisitor(SourceManager &SM,
5406 CXToken *tokens, unsigned numTokens)
5407 : SM(SM), Tokens(tokens), NumTokens(numTokens), CurIdx(0) { }
5408
5409 CXChildVisitResult visit(CXCursor cursor, CXCursor parent) {
5410 if (cursor.kind != CXCursor_MacroExpansion)
5411 return CXChildVisit_Continue;
5412
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +00005413 SourceRange macroRange = getCursorMacroExpansion(cursor).getSourceRange();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005414 if (macroRange.getBegin() == macroRange.getEnd())
5415 return CXChildVisit_Continue; // it's not a function macro.
5416
5417 for (; CurIdx < NumTokens; ++CurIdx) {
5418 if (!SM.isBeforeInTranslationUnit(getTokenLoc(CurIdx),
5419 macroRange.getBegin()))
5420 break;
5421 }
5422
5423 if (CurIdx == NumTokens)
5424 return CXChildVisit_Break;
5425
5426 for (; CurIdx < NumTokens; ++CurIdx) {
5427 SourceLocation tokLoc = getTokenLoc(CurIdx);
5428 if (!SM.isBeforeInTranslationUnit(tokLoc, macroRange.getEnd()))
5429 break;
5430
5431 setFunctionMacroTokenLoc(CurIdx, SM.getMacroArgExpandedLocation(tokLoc));
5432 }
5433
5434 if (CurIdx == NumTokens)
5435 return CXChildVisit_Break;
5436
5437 return CXChildVisit_Continue;
5438 }
5439
5440private:
5441 SourceLocation getTokenLoc(unsigned tokI) {
5442 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]);
5443 }
5444
5445 void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) {
5446 // The third field is reserved and currently not used. Use it here
5447 // to mark macro arg expanded tokens with their expanded locations.
5448 Tokens[tokI].int_data[3] = loc.getRawEncoding();
5449 }
5450};
5451
5452} // end anonymous namespace
5453
5454static CXChildVisitResult
5455MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent,
5456 CXClientData client_data) {
5457 return static_cast<MarkMacroArgTokensVisitor*>(client_data)->visit(cursor,
5458 parent);
5459}
5460
5461namespace {
5462 struct clang_annotateTokens_Data {
5463 CXTranslationUnit TU;
5464 ASTUnit *CXXUnit;
5465 CXToken *Tokens;
5466 unsigned NumTokens;
5467 CXCursor *Cursors;
5468 };
5469}
5470
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005471/// \brief Used by \c annotatePreprocessorTokens.
5472/// \returns true if lexing was finished, false otherwise.
5473static bool lexNext(Lexer &Lex, Token &Tok,
5474 unsigned &NextIdx, unsigned NumTokens) {
5475 if (NextIdx >= NumTokens)
5476 return true;
5477
5478 ++NextIdx;
5479 Lex.LexFromRawLexer(Tok);
5480 if (Tok.is(tok::eof))
5481 return true;
5482
5483 return false;
5484}
5485
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005486static void annotatePreprocessorTokens(CXTranslationUnit TU,
5487 SourceRange RegionOfInterest,
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005488 CXCursor *Cursors,
5489 CXToken *Tokens,
5490 unsigned NumTokens) {
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00005491 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005492
Argyrios Kyrtzidis3453bf72013-01-07 19:16:32 +00005493 Preprocessor &PP = CXXUnit->getPreprocessor();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005494 SourceManager &SourceMgr = CXXUnit->getSourceManager();
5495 std::pair<FileID, unsigned> BeginLocInfo
Argyrios Kyrtzidis82064212013-02-13 18:33:28 +00005496 = SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getBegin());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005497 std::pair<FileID, unsigned> EndLocInfo
Argyrios Kyrtzidis82064212013-02-13 18:33:28 +00005498 = SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getEnd());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005499
5500 if (BeginLocInfo.first != EndLocInfo.first)
5501 return;
5502
5503 StringRef Buffer;
5504 bool Invalid = false;
5505 Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
5506 if (Buffer.empty() || Invalid)
5507 return;
5508
5509 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
5510 CXXUnit->getASTContext().getLangOpts(),
5511 Buffer.begin(), Buffer.data() + BeginLocInfo.second,
5512 Buffer.end());
5513 Lex.SetCommentRetentionState(true);
5514
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005515 unsigned NextIdx = 0;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005516 // Lex tokens in raw mode until we hit the end of the range, to avoid
5517 // entering #includes or expanding macros.
5518 while (true) {
5519 Token Tok;
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005520 if (lexNext(Lex, Tok, NextIdx, NumTokens))
5521 break;
5522 unsigned TokIdx = NextIdx-1;
5523 assert(Tok.getLocation() ==
5524 SourceLocation::getFromRawEncoding(Tokens[TokIdx].int_data[1]));
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005525
5526 reprocess:
5527 if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) {
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005528 // We have found a preprocessing directive. Annotate the tokens
5529 // appropriately.
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005530 //
5531 // FIXME: Some simple tests here could identify macro definitions and
5532 // #undefs, to provide specific cursor kinds for those.
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005533
5534 SourceLocation BeginLoc = Tok.getLocation();
Argyrios Kyrtzidis3453bf72013-01-07 19:16:32 +00005535 if (lexNext(Lex, Tok, NextIdx, NumTokens))
5536 break;
5537
5538 MacroInfo *MI = 0;
5539 if (Tok.is(tok::raw_identifier) &&
5540 StringRef(Tok.getRawIdentifierData(), Tok.getLength()) == "define") {
5541 if (lexNext(Lex, Tok, NextIdx, NumTokens))
5542 break;
5543
5544 if (Tok.is(tok::raw_identifier)) {
5545 StringRef Name(Tok.getRawIdentifierData(), Tok.getLength());
5546 IdentifierInfo &II = PP.getIdentifierTable().get(Name);
5547 SourceLocation MappedTokLoc =
5548 CXXUnit->mapLocationToPreamble(Tok.getLocation());
5549 MI = getMacroInfo(II, MappedTokLoc, TU);
5550 }
5551 }
5552
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005553 bool finished = false;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005554 do {
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005555 if (lexNext(Lex, Tok, NextIdx, NumTokens)) {
5556 finished = true;
5557 break;
5558 }
Argyrios Kyrtzidis3453bf72013-01-07 19:16:32 +00005559 // If we are in a macro definition, check if the token was ever a
5560 // macro name and annotate it if that's the case.
5561 if (MI) {
5562 SourceLocation SaveLoc = Tok.getLocation();
5563 Tok.setLocation(CXXUnit->mapLocationToPreamble(SaveLoc));
5564 MacroDefinition *MacroDef = checkForMacroInMacroDefinition(MI,Tok,TU);
5565 Tok.setLocation(SaveLoc);
5566 if (MacroDef)
5567 Cursors[NextIdx-1] = MakeMacroExpansionCursor(MacroDef,
5568 Tok.getLocation(), TU);
5569 }
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005570 } while (!Tok.isAtStartOfLine());
5571
5572 unsigned LastIdx = finished ? NextIdx-1 : NextIdx-2;
5573 assert(TokIdx <= LastIdx);
5574 SourceLocation EndLoc =
5575 SourceLocation::getFromRawEncoding(Tokens[LastIdx].int_data[1]);
5576 CXCursor Cursor =
5577 MakePreprocessingDirectiveCursor(SourceRange(BeginLoc, EndLoc), TU);
5578
5579 for (; TokIdx <= LastIdx; ++TokIdx)
Argyrios Kyrtzidis3453bf72013-01-07 19:16:32 +00005580 updateCursorAnnotation(Cursors[TokIdx], Cursor);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005581
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005582 if (finished)
5583 break;
5584 goto reprocess;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005585 }
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005586 }
5587}
5588
5589// This gets run a separate thread to avoid stack blowout.
5590static void clang_annotateTokensImpl(void *UserData) {
5591 CXTranslationUnit TU = ((clang_annotateTokens_Data*)UserData)->TU;
5592 ASTUnit *CXXUnit = ((clang_annotateTokens_Data*)UserData)->CXXUnit;
5593 CXToken *Tokens = ((clang_annotateTokens_Data*)UserData)->Tokens;
5594 const unsigned NumTokens = ((clang_annotateTokens_Data*)UserData)->NumTokens;
5595 CXCursor *Cursors = ((clang_annotateTokens_Data*)UserData)->Cursors;
5596
Dmitri Gribenko8c718e72013-01-26 21:49:50 +00005597 CIndexer *CXXIdx = TU->CIdx;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005598 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
5599 setThreadBackgroundPriority();
5600
5601 // Determine the region of interest, which contains all of the tokens.
5602 SourceRange RegionOfInterest;
5603 RegionOfInterest.setBegin(
5604 cxloc::translateSourceLocation(clang_getTokenLocation(TU, Tokens[0])));
5605 RegionOfInterest.setEnd(
5606 cxloc::translateSourceLocation(clang_getTokenLocation(TU,
5607 Tokens[NumTokens-1])));
5608
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005609 // Relex the tokens within the source range to look for preprocessing
5610 // directives.
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005611 annotatePreprocessorTokens(TU, RegionOfInterest, Cursors, Tokens, NumTokens);
Argyrios Kyrtzidis82064212013-02-13 18:33:28 +00005612
5613 // If begin location points inside a macro argument, set it to the expansion
5614 // location so we can have the full context when annotating semantically.
5615 {
5616 SourceManager &SM = CXXUnit->getSourceManager();
5617 SourceLocation Loc =
5618 SM.getMacroArgExpandedLocation(RegionOfInterest.getBegin());
5619 if (Loc.isMacroID())
5620 RegionOfInterest.setBegin(SM.getExpansionLoc(Loc));
5621 }
5622
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005623 if (CXXUnit->getPreprocessor().getPreprocessingRecord()) {
5624 // Search and mark tokens that are macro argument expansions.
5625 MarkMacroArgTokensVisitor Visitor(CXXUnit->getSourceManager(),
5626 Tokens, NumTokens);
5627 CursorVisitor MacroArgMarker(TU,
5628 MarkMacroArgTokensVisitorDelegate, &Visitor,
5629 /*VisitPreprocessorLast=*/true,
5630 /*VisitIncludedEntities=*/false,
5631 RegionOfInterest);
5632 MacroArgMarker.visitPreprocessedEntitiesInRegion();
5633 }
5634
5635 // Annotate all of the source locations in the region of interest that map to
5636 // a specific cursor.
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00005637 AnnotateTokensWorker W(Tokens, Cursors, NumTokens, TU, RegionOfInterest);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005638
5639 // FIXME: We use a ridiculous stack size here because the data-recursion
5640 // algorithm uses a large stack frame than the non-data recursive version,
5641 // and AnnotationTokensWorker currently transforms the data-recursion
5642 // algorithm back into a traditional recursion by explicitly calling
5643 // VisitChildren(). We will need to remove this explicit recursive call.
5644 W.AnnotateTokens();
5645
5646 // If we ran into any entities that involve context-sensitive keywords,
5647 // take another pass through the tokens to mark them as such.
5648 if (W.hasContextSensitiveKeywords()) {
5649 for (unsigned I = 0; I != NumTokens; ++I) {
5650 if (clang_getTokenKind(Tokens[I]) != CXToken_Identifier)
5651 continue;
5652
5653 if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) {
5654 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data);
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005655 if (const ObjCPropertyDecl *Property
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005656 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(Cursors[I]))) {
5657 if (Property->getPropertyAttributesAsWritten() != 0 &&
5658 llvm::StringSwitch<bool>(II->getName())
5659 .Case("readonly", true)
5660 .Case("assign", true)
5661 .Case("unsafe_unretained", true)
5662 .Case("readwrite", true)
5663 .Case("retain", true)
5664 .Case("copy", true)
5665 .Case("nonatomic", true)
5666 .Case("atomic", true)
5667 .Case("getter", true)
5668 .Case("setter", true)
5669 .Case("strong", true)
5670 .Case("weak", true)
5671 .Default(false))
5672 Tokens[I].int_data[0] = CXToken_Keyword;
5673 }
5674 continue;
5675 }
5676
5677 if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl ||
5678 Cursors[I].kind == CXCursor_ObjCClassMethodDecl) {
5679 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data);
5680 if (llvm::StringSwitch<bool>(II->getName())
5681 .Case("in", true)
5682 .Case("out", true)
5683 .Case("inout", true)
5684 .Case("oneway", true)
5685 .Case("bycopy", true)
5686 .Case("byref", true)
5687 .Default(false))
5688 Tokens[I].int_data[0] = CXToken_Keyword;
5689 continue;
5690 }
5691
5692 if (Cursors[I].kind == CXCursor_CXXFinalAttr ||
5693 Cursors[I].kind == CXCursor_CXXOverrideAttr) {
5694 Tokens[I].int_data[0] = CXToken_Keyword;
5695 continue;
5696 }
5697 }
5698 }
5699}
5700
5701extern "C" {
5702
5703void clang_annotateTokens(CXTranslationUnit TU,
5704 CXToken *Tokens, unsigned NumTokens,
5705 CXCursor *Cursors) {
Argyrios Kyrtzidis0b602832013-04-04 22:40:59 +00005706 if (!TU || NumTokens == 0 || !Tokens || !Cursors) {
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00005707 LOG_FUNC_SECTION { *Log << "<null input>"; }
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005708 return;
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00005709 }
5710
5711 LOG_FUNC_SECTION {
5712 *Log << TU << ' ';
5713 CXSourceLocation bloc = clang_getTokenLocation(TU, Tokens[0]);
5714 CXSourceLocation eloc = clang_getTokenLocation(TU, Tokens[NumTokens-1]);
5715 *Log << clang_getRange(bloc, eloc);
5716 }
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005717
5718 // Any token we don't specifically annotate will have a NULL cursor.
5719 CXCursor C = clang_getNullCursor();
5720 for (unsigned I = 0; I != NumTokens; ++I)
5721 Cursors[I] = C;
5722
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00005723 ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005724 if (!CXXUnit)
5725 return;
5726
5727 ASTUnit::ConcurrencyCheck Check(*CXXUnit);
5728
5729 clang_annotateTokens_Data data = { TU, CXXUnit, Tokens, NumTokens, Cursors };
5730 llvm::CrashRecoveryContext CRC;
5731 if (!RunSafely(CRC, clang_annotateTokensImpl, &data,
5732 GetSafetyThreadStackSize() * 2)) {
5733 fprintf(stderr, "libclang: crash detected while annotating tokens\n");
5734 }
5735}
5736
5737} // end: extern "C"
5738
5739//===----------------------------------------------------------------------===//
5740// Operations for querying linkage of a cursor.
5741//===----------------------------------------------------------------------===//
5742
5743extern "C" {
5744CXLinkageKind clang_getCursorLinkage(CXCursor cursor) {
5745 if (!clang_isDeclaration(cursor.kind))
5746 return CXLinkage_Invalid;
5747
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005748 const Decl *D = cxcursor::getCursorDecl(cursor);
5749 if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D))
Rafael Espindola181e3ec2013-05-13 00:12:11 +00005750 switch (ND->getLinkageInternal()) {
Rafael Espindolaa99ecbc2013-05-25 17:16:20 +00005751 case NoLinkage:
5752 case VisibleNoLinkage: return CXLinkage_NoLinkage;
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005753 case InternalLinkage: return CXLinkage_Internal;
5754 case UniqueExternalLinkage: return CXLinkage_UniqueExternal;
5755 case ExternalLinkage: return CXLinkage_External;
5756 };
5757
5758 return CXLinkage_Invalid;
5759}
5760} // end: extern "C"
5761
5762//===----------------------------------------------------------------------===//
5763// Operations for querying language of a cursor.
5764//===----------------------------------------------------------------------===//
5765
5766static CXLanguageKind getDeclLanguage(const Decl *D) {
5767 if (!D)
5768 return CXLanguage_C;
5769
5770 switch (D->getKind()) {
5771 default:
5772 break;
5773 case Decl::ImplicitParam:
5774 case Decl::ObjCAtDefsField:
5775 case Decl::ObjCCategory:
5776 case Decl::ObjCCategoryImpl:
5777 case Decl::ObjCCompatibleAlias:
5778 case Decl::ObjCImplementation:
5779 case Decl::ObjCInterface:
5780 case Decl::ObjCIvar:
5781 case Decl::ObjCMethod:
5782 case Decl::ObjCProperty:
5783 case Decl::ObjCPropertyImpl:
5784 case Decl::ObjCProtocol:
5785 return CXLanguage_ObjC;
5786 case Decl::CXXConstructor:
5787 case Decl::CXXConversion:
5788 case Decl::CXXDestructor:
5789 case Decl::CXXMethod:
5790 case Decl::CXXRecord:
5791 case Decl::ClassTemplate:
5792 case Decl::ClassTemplatePartialSpecialization:
5793 case Decl::ClassTemplateSpecialization:
5794 case Decl::Friend:
5795 case Decl::FriendTemplate:
5796 case Decl::FunctionTemplate:
5797 case Decl::LinkageSpec:
5798 case Decl::Namespace:
5799 case Decl::NamespaceAlias:
5800 case Decl::NonTypeTemplateParm:
5801 case Decl::StaticAssert:
5802 case Decl::TemplateTemplateParm:
5803 case Decl::TemplateTypeParm:
5804 case Decl::UnresolvedUsingTypename:
5805 case Decl::UnresolvedUsingValue:
5806 case Decl::Using:
5807 case Decl::UsingDirective:
5808 case Decl::UsingShadow:
5809 return CXLanguage_CPlusPlus;
5810 }
5811
5812 return CXLanguage_C;
5813}
5814
5815extern "C" {
5816
5817enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) {
5818 if (clang_isDeclaration(cursor.kind))
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005819 if (const Decl *D = cxcursor::getCursorDecl(cursor)) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005820 if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted())
5821 return CXAvailability_Available;
5822
5823 switch (D->getAvailability()) {
5824 case AR_Available:
5825 case AR_NotYetIntroduced:
5826 return CXAvailability_Available;
5827
5828 case AR_Deprecated:
5829 return CXAvailability_Deprecated;
5830
5831 case AR_Unavailable:
5832 return CXAvailability_NotAvailable;
5833 }
5834 }
5835
5836 return CXAvailability_Available;
5837}
5838
5839static CXVersion convertVersion(VersionTuple In) {
5840 CXVersion Out = { -1, -1, -1 };
5841 if (In.empty())
5842 return Out;
5843
5844 Out.Major = In.getMajor();
5845
NAKAMURA Takumi4a3012d2013-02-21 02:32:34 +00005846 Optional<unsigned> Minor = In.getMinor();
5847 if (Minor.hasValue())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005848 Out.Minor = *Minor;
5849 else
5850 return Out;
5851
NAKAMURA Takumi4a3012d2013-02-21 02:32:34 +00005852 Optional<unsigned> Subminor = In.getSubminor();
5853 if (Subminor.hasValue())
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005854 Out.Subminor = *Subminor;
5855
5856 return Out;
5857}
5858
5859int clang_getCursorPlatformAvailability(CXCursor cursor,
5860 int *always_deprecated,
5861 CXString *deprecated_message,
5862 int *always_unavailable,
5863 CXString *unavailable_message,
5864 CXPlatformAvailability *availability,
5865 int availability_size) {
5866 if (always_deprecated)
5867 *always_deprecated = 0;
5868 if (deprecated_message)
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00005869 *deprecated_message = cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005870 if (always_unavailable)
5871 *always_unavailable = 0;
5872 if (unavailable_message)
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00005873 *unavailable_message = cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005874
5875 if (!clang_isDeclaration(cursor.kind))
5876 return 0;
5877
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005878 const Decl *D = cxcursor::getCursorDecl(cursor);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005879 if (!D)
5880 return 0;
5881
5882 int N = 0;
5883 for (Decl::attr_iterator A = D->attr_begin(), AEnd = D->attr_end(); A != AEnd;
5884 ++A) {
5885 if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(*A)) {
5886 if (always_deprecated)
5887 *always_deprecated = 1;
5888 if (deprecated_message)
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00005889 *deprecated_message = cxstring::createDup(Deprecated->getMessage());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005890 continue;
5891 }
5892
5893 if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(*A)) {
5894 if (always_unavailable)
5895 *always_unavailable = 1;
5896 if (unavailable_message) {
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00005897 *unavailable_message = cxstring::createDup(Unavailable->getMessage());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005898 }
5899 continue;
5900 }
5901
5902 if (AvailabilityAttr *Avail = dyn_cast<AvailabilityAttr>(*A)) {
5903 if (N < availability_size) {
5904 availability[N].Platform
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00005905 = cxstring::createDup(Avail->getPlatform()->getName());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005906 availability[N].Introduced = convertVersion(Avail->getIntroduced());
5907 availability[N].Deprecated = convertVersion(Avail->getDeprecated());
5908 availability[N].Obsoleted = convertVersion(Avail->getObsoleted());
5909 availability[N].Unavailable = Avail->getUnavailable();
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00005910 availability[N].Message = cxstring::createDup(Avail->getMessage());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005911 }
5912 ++N;
5913 }
5914 }
5915
5916 return N;
5917}
5918
5919void clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability) {
5920 clang_disposeString(availability->Platform);
5921 clang_disposeString(availability->Message);
5922}
5923
5924CXLanguageKind clang_getCursorLanguage(CXCursor cursor) {
5925 if (clang_isDeclaration(cursor.kind))
5926 return getDeclLanguage(cxcursor::getCursorDecl(cursor));
5927
5928 return CXLanguage_Invalid;
5929}
5930
5931 /// \brief If the given cursor is the "templated" declaration
5932 /// descibing a class or function template, return the class or
5933 /// function template.
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005934static const Decl *maybeGetTemplateCursor(const Decl *D) {
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005935 if (!D)
5936 return 0;
5937
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005938 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005939 if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate())
5940 return FunTmpl;
5941
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005942 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005943 if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate())
5944 return ClassTmpl;
5945
5946 return D;
5947}
5948
5949CXCursor clang_getCursorSemanticParent(CXCursor cursor) {
5950 if (clang_isDeclaration(cursor.kind)) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005951 if (const Decl *D = getCursorDecl(cursor)) {
5952 const DeclContext *DC = D->getDeclContext();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005953 if (!DC)
5954 return clang_getNullCursor();
5955
5956 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)),
5957 getCursorTU(cursor));
5958 }
5959 }
5960
5961 if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005962 if (const Decl *D = getCursorDecl(cursor))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005963 return MakeCXCursor(D, getCursorTU(cursor));
5964 }
5965
5966 return clang_getNullCursor();
5967}
5968
5969CXCursor clang_getCursorLexicalParent(CXCursor cursor) {
5970 if (clang_isDeclaration(cursor.kind)) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00005971 if (const Decl *D = getCursorDecl(cursor)) {
5972 const DeclContext *DC = D->getLexicalDeclContext();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005973 if (!DC)
5974 return clang_getNullCursor();
5975
5976 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)),
5977 getCursorTU(cursor));
5978 }
5979 }
5980
5981 // FIXME: Note that we can't easily compute the lexical context of a
5982 // statement or expression, so we return nothing.
5983 return clang_getNullCursor();
5984}
5985
5986CXFile clang_getIncludedFile(CXCursor cursor) {
5987 if (cursor.kind != CXCursor_InclusionDirective)
5988 return 0;
5989
Dmitri Gribenko67812b22013-01-11 21:01:49 +00005990 const InclusionDirective *ID = getCursorInclusionDirective(cursor);
Dmitri Gribenkoe4ea8792013-01-23 15:56:07 +00005991 return const_cast<FileEntry *>(ID->getFile());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00005992}
5993
Argyrios Kyrtzidis9ee6a662013-04-18 22:15:49 +00005994unsigned clang_Cursor_getObjCPropertyAttributes(CXCursor C, unsigned reserved) {
5995 if (C.kind != CXCursor_ObjCPropertyDecl)
5996 return CXObjCPropertyAttr_noattr;
5997
5998 unsigned Result = CXObjCPropertyAttr_noattr;
5999 const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(getCursorDecl(C));
6000 ObjCPropertyDecl::PropertyAttributeKind Attr =
6001 PD->getPropertyAttributesAsWritten();
6002
6003#define SET_CXOBJCPROP_ATTR(A) \
6004 if (Attr & ObjCPropertyDecl::OBJC_PR_##A) \
6005 Result |= CXObjCPropertyAttr_##A
6006 SET_CXOBJCPROP_ATTR(readonly);
6007 SET_CXOBJCPROP_ATTR(getter);
6008 SET_CXOBJCPROP_ATTR(assign);
6009 SET_CXOBJCPROP_ATTR(readwrite);
6010 SET_CXOBJCPROP_ATTR(retain);
6011 SET_CXOBJCPROP_ATTR(copy);
6012 SET_CXOBJCPROP_ATTR(nonatomic);
6013 SET_CXOBJCPROP_ATTR(setter);
6014 SET_CXOBJCPROP_ATTR(atomic);
6015 SET_CXOBJCPROP_ATTR(weak);
6016 SET_CXOBJCPROP_ATTR(strong);
6017 SET_CXOBJCPROP_ATTR(unsafe_unretained);
6018#undef SET_CXOBJCPROP_ATTR
6019
6020 return Result;
6021}
6022
Argyrios Kyrtzidis38dbad22013-04-18 23:29:12 +00006023unsigned clang_Cursor_getObjCDeclQualifiers(CXCursor C) {
6024 if (!clang_isDeclaration(C.kind))
6025 return CXObjCDeclQualifier_None;
6026
6027 Decl::ObjCDeclQualifier QT = Decl::OBJC_TQ_None;
6028 const Decl *D = getCursorDecl(C);
6029 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
6030 QT = MD->getObjCDeclQualifier();
6031 else if (const ParmVarDecl *PD = dyn_cast<ParmVarDecl>(D))
6032 QT = PD->getObjCDeclQualifier();
6033 if (QT == Decl::OBJC_TQ_None)
6034 return CXObjCDeclQualifier_None;
6035
6036 unsigned Result = CXObjCDeclQualifier_None;
6037 if (QT & Decl::OBJC_TQ_In) Result |= CXObjCDeclQualifier_In;
6038 if (QT & Decl::OBJC_TQ_Inout) Result |= CXObjCDeclQualifier_Inout;
6039 if (QT & Decl::OBJC_TQ_Out) Result |= CXObjCDeclQualifier_Out;
6040 if (QT & Decl::OBJC_TQ_Bycopy) Result |= CXObjCDeclQualifier_Bycopy;
6041 if (QT & Decl::OBJC_TQ_Byref) Result |= CXObjCDeclQualifier_Byref;
6042 if (QT & Decl::OBJC_TQ_Oneway) Result |= CXObjCDeclQualifier_Oneway;
6043
6044 return Result;
6045}
6046
Argyrios Kyrtzidis514afc72013-07-05 20:44:37 +00006047unsigned clang_Cursor_isObjCOptional(CXCursor C) {
6048 if (!clang_isDeclaration(C.kind))
6049 return 0;
6050
6051 const Decl *D = getCursorDecl(C);
6052 if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
6053 return PD->getPropertyImplementation() == ObjCPropertyDecl::Optional;
6054 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
6055 return MD->getImplementationControl() == ObjCMethodDecl::Optional;
6056
6057 return 0;
6058}
6059
Argyrios Kyrtzidis80e1aca2013-04-18 23:53:05 +00006060unsigned clang_Cursor_isVariadic(CXCursor C) {
6061 if (!clang_isDeclaration(C.kind))
6062 return 0;
6063
6064 const Decl *D = getCursorDecl(C);
6065 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
6066 return FD->isVariadic();
6067 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
6068 return MD->isVariadic();
6069
6070 return 0;
6071}
6072
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006073CXSourceRange clang_Cursor_getCommentRange(CXCursor C) {
6074 if (!clang_isDeclaration(C.kind))
6075 return clang_getNullRange();
6076
6077 const Decl *D = getCursorDecl(C);
6078 ASTContext &Context = getCursorContext(C);
6079 const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
6080 if (!RC)
6081 return clang_getNullRange();
6082
6083 return cxloc::translateSourceRange(Context, RC->getSourceRange());
6084}
6085
6086CXString clang_Cursor_getRawCommentText(CXCursor C) {
6087 if (!clang_isDeclaration(C.kind))
Dmitri Gribenkodad4c1a2013-02-01 14:13:32 +00006088 return cxstring::createNull();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006089
6090 const Decl *D = getCursorDecl(C);
6091 ASTContext &Context = getCursorContext(C);
6092 const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
6093 StringRef RawText = RC ? RC->getRawText(Context.getSourceManager()) :
6094 StringRef();
6095
6096 // Don't duplicate the string because RawText points directly into source
6097 // code.
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00006098 return cxstring::createRef(RawText);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006099}
6100
6101CXString clang_Cursor_getBriefCommentText(CXCursor C) {
6102 if (!clang_isDeclaration(C.kind))
Dmitri Gribenkodad4c1a2013-02-01 14:13:32 +00006103 return cxstring::createNull();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006104
6105 const Decl *D = getCursorDecl(C);
6106 const ASTContext &Context = getCursorContext(C);
6107 const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
6108
6109 if (RC) {
6110 StringRef BriefText = RC->getBriefText(Context);
6111
6112 // Don't duplicate the string because RawComment ensures that this memory
6113 // will not go away.
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00006114 return cxstring::createRef(BriefText);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006115 }
6116
Dmitri Gribenkodad4c1a2013-02-01 14:13:32 +00006117 return cxstring::createNull();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006118}
6119
6120CXComment clang_Cursor_getParsedComment(CXCursor C) {
6121 if (!clang_isDeclaration(C.kind))
6122 return cxcomment::createCXComment(NULL, NULL);
6123
6124 const Decl *D = getCursorDecl(C);
6125 const ASTContext &Context = getCursorContext(C);
6126 const comments::FullComment *FC = Context.getCommentForDecl(D, /*PP=*/ NULL);
6127
6128 return cxcomment::createCXComment(FC, getCursorTU(C));
6129}
6130
6131CXModule clang_Cursor_getModule(CXCursor C) {
6132 if (C.kind == CXCursor_ModuleImportDecl) {
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00006133 if (const ImportDecl *ImportD =
6134 dyn_cast_or_null<ImportDecl>(getCursorDecl(C)))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006135 return ImportD->getImportedModule();
6136 }
6137
6138 return 0;
6139}
6140
Argyrios Kyrtzidise858e662013-04-26 22:47:49 +00006141CXFile clang_Module_getASTFile(CXModule CXMod) {
6142 if (!CXMod)
6143 return 0;
6144 Module *Mod = static_cast<Module*>(CXMod);
6145 return const_cast<FileEntry *>(Mod->getASTFile());
6146}
6147
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006148CXModule clang_Module_getParent(CXModule CXMod) {
6149 if (!CXMod)
6150 return 0;
6151 Module *Mod = static_cast<Module*>(CXMod);
6152 return Mod->Parent;
6153}
6154
6155CXString clang_Module_getName(CXModule CXMod) {
6156 if (!CXMod)
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00006157 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006158 Module *Mod = static_cast<Module*>(CXMod);
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00006159 return cxstring::createDup(Mod->Name);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006160}
6161
6162CXString clang_Module_getFullName(CXModule CXMod) {
6163 if (!CXMod)
Dmitri Gribenkodc66adb2013-02-01 14:21:22 +00006164 return cxstring::createEmpty();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006165 Module *Mod = static_cast<Module*>(CXMod);
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00006166 return cxstring::createDup(Mod->getFullModuleName());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006167}
6168
Argyrios Kyrtzidisc1d22392013-03-13 21:13:43 +00006169unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit TU,
6170 CXModule CXMod) {
6171 if (!TU || !CXMod)
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006172 return 0;
6173 Module *Mod = static_cast<Module*>(CXMod);
Argyrios Kyrtzidisc1d22392013-03-13 21:13:43 +00006174 FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();
6175 ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
6176 return TopHeaders.size();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006177}
6178
Argyrios Kyrtzidisc1d22392013-03-13 21:13:43 +00006179CXFile clang_Module_getTopLevelHeader(CXTranslationUnit TU,
6180 CXModule CXMod, unsigned Index) {
6181 if (!TU || !CXMod)
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006182 return 0;
6183 Module *Mod = static_cast<Module*>(CXMod);
Argyrios Kyrtzidisc1d22392013-03-13 21:13:43 +00006184 FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006185
Argyrios Kyrtzidisc1d22392013-03-13 21:13:43 +00006186 ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
6187 if (Index < TopHeaders.size())
6188 return const_cast<FileEntry *>(TopHeaders[Index]);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006189
6190 return 0;
6191}
6192
6193} // end: extern "C"
6194
6195//===----------------------------------------------------------------------===//
6196// C++ AST instrospection.
6197//===----------------------------------------------------------------------===//
6198
6199extern "C" {
Dmitri Gribenkoc965f762013-05-17 18:38:35 +00006200unsigned clang_CXXMethod_isPureVirtual(CXCursor C) {
6201 if (!clang_isDeclaration(C.kind))
6202 return 0;
6203
6204 const CXXMethodDecl *Method = 0;
6205 const Decl *D = cxcursor::getCursorDecl(C);
6206 if (const FunctionTemplateDecl *FunTmpl =
6207 dyn_cast_or_null<FunctionTemplateDecl>(D))
6208 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
6209 else
6210 Method = dyn_cast_or_null<CXXMethodDecl>(D);
6211 return (Method && Method->isVirtual() && Method->isPure()) ? 1 : 0;
6212}
6213
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006214unsigned clang_CXXMethod_isStatic(CXCursor C) {
6215 if (!clang_isDeclaration(C.kind))
6216 return 0;
6217
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00006218 const CXXMethodDecl *Method = 0;
6219 const Decl *D = cxcursor::getCursorDecl(C);
6220 if (const FunctionTemplateDecl *FunTmpl =
6221 dyn_cast_or_null<FunctionTemplateDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006222 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
6223 else
6224 Method = dyn_cast_or_null<CXXMethodDecl>(D);
6225 return (Method && Method->isStatic()) ? 1 : 0;
6226}
6227
6228unsigned clang_CXXMethod_isVirtual(CXCursor C) {
6229 if (!clang_isDeclaration(C.kind))
6230 return 0;
6231
Dmitri Gribenkoe22339c2013-01-23 17:25:27 +00006232 const CXXMethodDecl *Method = 0;
6233 const Decl *D = cxcursor::getCursorDecl(C);
6234 if (const FunctionTemplateDecl *FunTmpl =
6235 dyn_cast_or_null<FunctionTemplateDecl>(D))
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006236 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
6237 else
6238 Method = dyn_cast_or_null<CXXMethodDecl>(D);
6239 return (Method && Method->isVirtual()) ? 1 : 0;
6240}
6241} // end: extern "C"
6242
6243//===----------------------------------------------------------------------===//
6244// Attribute introspection.
6245//===----------------------------------------------------------------------===//
6246
6247extern "C" {
6248CXType clang_getIBOutletCollectionType(CXCursor C) {
6249 if (C.kind != CXCursor_IBOutletCollectionAttr)
6250 return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C));
6251
Dmitri Gribenko7d914382013-01-26 18:08:08 +00006252 const IBOutletCollectionAttr *A =
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006253 cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C));
6254
6255 return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorTU(C));
6256}
6257} // end: extern "C"
6258
6259//===----------------------------------------------------------------------===//
6260// Inspecting memory usage.
6261//===----------------------------------------------------------------------===//
6262
6263typedef std::vector<CXTUResourceUsageEntry> MemUsageEntries;
6264
6265static inline void createCXTUResourceUsageEntry(MemUsageEntries &entries,
6266 enum CXTUResourceUsageKind k,
6267 unsigned long amount) {
6268 CXTUResourceUsageEntry entry = { k, amount };
6269 entries.push_back(entry);
6270}
6271
6272extern "C" {
6273
6274const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) {
6275 const char *str = "";
6276 switch (kind) {
6277 case CXTUResourceUsage_AST:
6278 str = "ASTContext: expressions, declarations, and types";
6279 break;
6280 case CXTUResourceUsage_Identifiers:
6281 str = "ASTContext: identifiers";
6282 break;
6283 case CXTUResourceUsage_Selectors:
6284 str = "ASTContext: selectors";
6285 break;
6286 case CXTUResourceUsage_GlobalCompletionResults:
6287 str = "Code completion: cached global results";
6288 break;
6289 case CXTUResourceUsage_SourceManagerContentCache:
6290 str = "SourceManager: content cache allocator";
6291 break;
6292 case CXTUResourceUsage_AST_SideTables:
6293 str = "ASTContext: side tables";
6294 break;
6295 case CXTUResourceUsage_SourceManager_Membuffer_Malloc:
6296 str = "SourceManager: malloc'ed memory buffers";
6297 break;
6298 case CXTUResourceUsage_SourceManager_Membuffer_MMap:
6299 str = "SourceManager: mmap'ed memory buffers";
6300 break;
6301 case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc:
6302 str = "ExternalASTSource: malloc'ed memory buffers";
6303 break;
6304 case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap:
6305 str = "ExternalASTSource: mmap'ed memory buffers";
6306 break;
6307 case CXTUResourceUsage_Preprocessor:
6308 str = "Preprocessor: malloc'ed memory";
6309 break;
6310 case CXTUResourceUsage_PreprocessingRecord:
6311 str = "Preprocessor: PreprocessingRecord";
6312 break;
6313 case CXTUResourceUsage_SourceManager_DataStructures:
6314 str = "SourceManager: data structures and tables";
6315 break;
6316 case CXTUResourceUsage_Preprocessor_HeaderSearch:
6317 str = "Preprocessor: header search tables";
6318 break;
6319 }
6320 return str;
6321}
6322
6323CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU) {
6324 if (!TU) {
6325 CXTUResourceUsage usage = { (void*) 0, 0, 0 };
6326 return usage;
6327 }
6328
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00006329 ASTUnit *astUnit = cxtu::getASTUnit(TU);
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006330 OwningPtr<MemUsageEntries> entries(new MemUsageEntries());
6331 ASTContext &astContext = astUnit->getASTContext();
6332
6333 // How much memory is used by AST nodes and types?
6334 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST,
6335 (unsigned long) astContext.getASTAllocatedMemory());
6336
6337 // How much memory is used by identifiers?
6338 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Identifiers,
6339 (unsigned long) astContext.Idents.getAllocator().getTotalMemory());
6340
6341 // How much memory is used for selectors?
6342 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Selectors,
6343 (unsigned long) astContext.Selectors.getTotalMemory());
6344
6345 // How much memory is used by ASTContext's side tables?
6346 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST_SideTables,
6347 (unsigned long) astContext.getSideTableAllocatedMemory());
6348
6349 // How much memory is used for caching global code completion results?
6350 unsigned long completionBytes = 0;
6351 if (GlobalCodeCompletionAllocator *completionAllocator =
6352 astUnit->getCachedCompletionAllocator().getPtr()) {
6353 completionBytes = completionAllocator->getTotalMemory();
6354 }
6355 createCXTUResourceUsageEntry(*entries,
6356 CXTUResourceUsage_GlobalCompletionResults,
6357 completionBytes);
6358
6359 // How much memory is being used by SourceManager's content cache?
6360 createCXTUResourceUsageEntry(*entries,
6361 CXTUResourceUsage_SourceManagerContentCache,
6362 (unsigned long) astContext.getSourceManager().getContentCacheSize());
6363
6364 // How much memory is being used by the MemoryBuffer's in SourceManager?
6365 const SourceManager::MemoryBufferSizes &srcBufs =
6366 astUnit->getSourceManager().getMemoryBufferSizes();
6367
6368 createCXTUResourceUsageEntry(*entries,
6369 CXTUResourceUsage_SourceManager_Membuffer_Malloc,
6370 (unsigned long) srcBufs.malloc_bytes);
6371 createCXTUResourceUsageEntry(*entries,
6372 CXTUResourceUsage_SourceManager_Membuffer_MMap,
6373 (unsigned long) srcBufs.mmap_bytes);
6374 createCXTUResourceUsageEntry(*entries,
6375 CXTUResourceUsage_SourceManager_DataStructures,
6376 (unsigned long) astContext.getSourceManager()
6377 .getDataStructureSizes());
6378
6379 // How much memory is being used by the ExternalASTSource?
6380 if (ExternalASTSource *esrc = astContext.getExternalSource()) {
6381 const ExternalASTSource::MemoryBufferSizes &sizes =
6382 esrc->getMemoryBufferSizes();
6383
6384 createCXTUResourceUsageEntry(*entries,
6385 CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc,
6386 (unsigned long) sizes.malloc_bytes);
6387 createCXTUResourceUsageEntry(*entries,
6388 CXTUResourceUsage_ExternalASTSource_Membuffer_MMap,
6389 (unsigned long) sizes.mmap_bytes);
6390 }
6391
6392 // How much memory is being used by the Preprocessor?
6393 Preprocessor &pp = astUnit->getPreprocessor();
6394 createCXTUResourceUsageEntry(*entries,
6395 CXTUResourceUsage_Preprocessor,
6396 pp.getTotalMemory());
6397
6398 if (PreprocessingRecord *pRec = pp.getPreprocessingRecord()) {
6399 createCXTUResourceUsageEntry(*entries,
6400 CXTUResourceUsage_PreprocessingRecord,
6401 pRec->getTotalMemory());
6402 }
6403
6404 createCXTUResourceUsageEntry(*entries,
6405 CXTUResourceUsage_Preprocessor_HeaderSearch,
6406 pp.getHeaderSearchInfo().getTotalMemory());
6407
6408 CXTUResourceUsage usage = { (void*) entries.get(),
6409 (unsigned) entries->size(),
6410 entries->size() ? &(*entries)[0] : 0 };
6411 entries.take();
6412 return usage;
6413}
6414
6415void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage) {
6416 if (usage.data)
6417 delete (MemUsageEntries*) usage.data;
6418}
6419
6420} // end extern "C"
6421
6422void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) {
6423 CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU);
6424 for (unsigned I = 0; I != Usage.numEntries; ++I)
6425 fprintf(stderr, " %s: %lu\n",
6426 clang_getTUResourceUsageName(Usage.entries[I].kind),
6427 Usage.entries[I].amount);
6428
6429 clang_disposeCXTUResourceUsage(Usage);
6430}
6431
6432//===----------------------------------------------------------------------===//
6433// Misc. utility functions.
6434//===----------------------------------------------------------------------===//
6435
6436/// Default to using an 8 MB stack size on "safety" threads.
6437static unsigned SafetyStackThreadSize = 8 << 20;
6438
6439namespace clang {
6440
6441bool RunSafely(llvm::CrashRecoveryContext &CRC,
6442 void (*Fn)(void*), void *UserData,
6443 unsigned Size) {
6444 if (!Size)
6445 Size = GetSafetyThreadStackSize();
6446 if (Size)
6447 return CRC.RunSafelyOnThread(Fn, UserData, Size);
6448 return CRC.RunSafely(Fn, UserData);
6449}
6450
6451unsigned GetSafetyThreadStackSize() {
6452 return SafetyStackThreadSize;
6453}
6454
6455void SetSafetyThreadStackSize(unsigned Value) {
6456 SafetyStackThreadSize = Value;
6457}
6458
6459}
6460
6461void clang::setThreadBackgroundPriority() {
6462 if (getenv("LIBCLANG_BGPRIO_DISABLE"))
6463 return;
6464
6465 // FIXME: Move to llvm/Support and make it cross-platform.
6466#ifdef __APPLE__
6467 setpriority(PRIO_DARWIN_THREAD, 0, PRIO_DARWIN_BG);
6468#endif
6469}
6470
6471void cxindex::printDiagsToStderr(ASTUnit *Unit) {
6472 if (!Unit)
6473 return;
6474
6475 for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(),
6476 DEnd = Unit->stored_diag_end();
6477 D != DEnd; ++D) {
6478 CXStoredDiagnostic Diag(*D, Unit->getASTContext().getLangOpts());
6479 CXString Msg = clang_formatDiagnostic(&Diag,
6480 clang_defaultDiagnosticDisplayOptions());
6481 fprintf(stderr, "%s\n", clang_getCString(Msg));
6482 clang_disposeString(Msg);
6483 }
6484#ifdef LLVM_ON_WIN32
6485 // On Windows, force a flush, since there may be multiple copies of
6486 // stderr and stdout in the file system, all with different buffers
6487 // but writing to the same device.
6488 fflush(stderr);
6489#endif
6490}
6491
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +00006492MacroInfo *cxindex::getMacroInfo(const IdentifierInfo &II,
6493 SourceLocation MacroDefLoc,
6494 CXTranslationUnit TU){
6495 if (MacroDefLoc.isInvalid() || !TU)
6496 return 0;
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +00006497 if (!II.hadMacroDefinition())
6498 return 0;
6499
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00006500 ASTUnit *Unit = cxtu::getASTUnit(TU);
Argyrios Kyrtzidisc059f892013-01-07 19:16:30 +00006501 Preprocessor &PP = Unit->getPreprocessor();
Argyrios Kyrtzidis9818a1d2013-02-20 00:54:57 +00006502 MacroDirective *MD = PP.getMacroDirectiveHistory(&II);
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +00006503 if (MD) {
6504 for (MacroDirective::DefInfo
6505 Def = MD->getDefinition(); Def; Def = Def.getPreviousDefinition()) {
6506 if (MacroDefLoc == Def.getMacroInfo()->getDefinitionLoc())
6507 return Def.getMacroInfo();
6508 }
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +00006509 }
6510
6511 return 0;
6512}
6513
Dmitri Gribenko67812b22013-01-11 21:01:49 +00006514const MacroInfo *cxindex::getMacroInfo(const MacroDefinition *MacroDef,
6515 CXTranslationUnit TU) {
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +00006516 if (!MacroDef || !TU)
6517 return 0;
6518 const IdentifierInfo *II = MacroDef->getName();
6519 if (!II)
6520 return 0;
6521
6522 return getMacroInfo(*II, MacroDef->getLocation(), TU);
6523}
6524
6525MacroDefinition *cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI,
6526 const Token &Tok,
6527 CXTranslationUnit TU) {
6528 if (!MI || !TU)
6529 return 0;
6530 if (Tok.isNot(tok::raw_identifier))
6531 return 0;
6532
6533 if (MI->getNumTokens() == 0)
6534 return 0;
6535 SourceRange DefRange(MI->getReplacementToken(0).getLocation(),
6536 MI->getDefinitionEndLoc());
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00006537 ASTUnit *Unit = cxtu::getASTUnit(TU);
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +00006538
6539 // Check that the token is inside the definition and not its argument list.
6540 SourceManager &SM = Unit->getSourceManager();
6541 if (SM.isBeforeInTranslationUnit(Tok.getLocation(), DefRange.getBegin()))
6542 return 0;
6543 if (SM.isBeforeInTranslationUnit(DefRange.getEnd(), Tok.getLocation()))
6544 return 0;
6545
6546 Preprocessor &PP = Unit->getPreprocessor();
6547 PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
6548 if (!PPRec)
6549 return 0;
6550
6551 StringRef Name(Tok.getRawIdentifierData(), Tok.getLength());
6552 IdentifierInfo &II = PP.getIdentifierTable().get(Name);
6553 if (!II.hadMacroDefinition())
6554 return 0;
6555
6556 // Check that the identifier is not one of the macro arguments.
6557 if (std::find(MI->arg_begin(), MI->arg_end(), &II) != MI->arg_end())
6558 return 0;
6559
Argyrios Kyrtzidis9818a1d2013-02-20 00:54:57 +00006560 MacroDirective *InnerMD = PP.getMacroDirectiveHistory(&II);
6561 if (!InnerMD)
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +00006562 return 0;
6563
Argyrios Kyrtzidisc56fff72013-03-26 17:17:01 +00006564 return PPRec->findMacroDefinition(InnerMD->getMacroInfo());
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +00006565}
6566
6567MacroDefinition *cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI,
6568 SourceLocation Loc,
6569 CXTranslationUnit TU) {
6570 if (Loc.isInvalid() || !MI || !TU)
6571 return 0;
6572
6573 if (MI->getNumTokens() == 0)
6574 return 0;
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00006575 ASTUnit *Unit = cxtu::getASTUnit(TU);
Argyrios Kyrtzidis664b06f2013-01-07 19:16:25 +00006576 Preprocessor &PP = Unit->getPreprocessor();
6577 if (!PP.getPreprocessingRecord())
6578 return 0;
6579 Loc = Unit->getSourceManager().getSpellingLoc(Loc);
6580 Token Tok;
6581 if (PP.getRawToken(Loc, Tok))
6582 return 0;
6583
6584 return checkForMacroInMacroDefinition(MI, Tok, TU);
6585}
6586
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006587extern "C" {
6588
6589CXString clang_getClangVersion() {
Dmitri Gribenko5595ded2013-02-02 02:19:29 +00006590 return cxstring::createDup(getClangFullVersion());
Guy Benyei7f92f2d2012-12-18 14:30:41 +00006591}
6592
6593} // end: extern "C"
6594
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00006595Logger &cxindex::Logger::operator<<(CXTranslationUnit TU) {
6596 if (TU) {
Dmitri Gribenko5694feb2013-01-26 18:53:38 +00006597 if (ASTUnit *Unit = cxtu::getASTUnit(TU)) {
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00006598 LogOS << '<' << Unit->getMainFileName() << '>';
Argyrios Kyrtzidis44f65a52013-03-05 20:21:14 +00006599 if (Unit->isMainFileAST())
6600 LogOS << " (" << Unit->getASTFileName() << ')';
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00006601 return *this;
6602 }
6603 }
6604
6605 LogOS << "<NULL TU>";
6606 return *this;
6607}
6608
Argyrios Kyrtzidisb70e7a82013-03-08 02:32:26 +00006609Logger &cxindex::Logger::operator<<(const FileEntry *FE) {
6610 *this << FE->getName();
6611 return *this;
6612}
6613
6614Logger &cxindex::Logger::operator<<(CXCursor cursor) {
6615 CXString cursorName = clang_getCursorDisplayName(cursor);
6616 *this << cursorName << "@" << clang_getCursorLocation(cursor);
6617 clang_disposeString(cursorName);
6618 return *this;
6619}
6620
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00006621Logger &cxindex::Logger::operator<<(CXSourceLocation Loc) {
6622 CXFile File;
6623 unsigned Line, Column;
6624 clang_getFileLocation(Loc, &File, &Line, &Column, 0);
6625 CXString FileName = clang_getFileName(File);
6626 *this << llvm::format("(%s:%d:%d)", clang_getCString(FileName), Line, Column);
6627 clang_disposeString(FileName);
6628 return *this;
6629}
6630
6631Logger &cxindex::Logger::operator<<(CXSourceRange range) {
6632 CXSourceLocation BLoc = clang_getRangeStart(range);
6633 CXSourceLocation ELoc = clang_getRangeEnd(range);
6634
6635 CXFile BFile;
6636 unsigned BLine, BColumn;
6637 clang_getFileLocation(BLoc, &BFile, &BLine, &BColumn, 0);
6638
6639 CXFile EFile;
6640 unsigned ELine, EColumn;
6641 clang_getFileLocation(ELoc, &EFile, &ELine, &EColumn, 0);
6642
6643 CXString BFileName = clang_getFileName(BFile);
6644 if (BFile == EFile) {
6645 *this << llvm::format("[%s %d:%d-%d:%d]", clang_getCString(BFileName),
6646 BLine, BColumn, ELine, EColumn);
6647 } else {
6648 CXString EFileName = clang_getFileName(EFile);
6649 *this << llvm::format("[%s:%d:%d - ", clang_getCString(BFileName),
6650 BLine, BColumn)
6651 << llvm::format("%s:%d:%d]", clang_getCString(EFileName),
6652 ELine, EColumn);
6653 clang_disposeString(EFileName);
6654 }
6655 clang_disposeString(BFileName);
6656 return *this;
6657}
6658
6659Logger &cxindex::Logger::operator<<(CXString Str) {
6660 *this << clang_getCString(Str);
6661 return *this;
6662}
6663
6664Logger &cxindex::Logger::operator<<(const llvm::format_object_base &Fmt) {
6665 LogOS << Fmt;
6666 return *this;
6667}
6668
6669cxindex::Logger::~Logger() {
6670 LogOS.flush();
6671
6672 llvm::sys::ScopedLock L(EnableMultithreadingMutex);
6673
6674 static llvm::TimeRecord sBeginTR = llvm::TimeRecord::getCurrentTime();
6675
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00006676 raw_ostream &OS = llvm::errs();
Argyrios Kyrtzidisc6f5c6a2013-01-10 18:54:52 +00006677 OS << "[libclang:" << Name << ':';
6678
6679 // FIXME: Portability.
6680#if HAVE_PTHREAD_H && __APPLE__
6681 mach_port_t tid = pthread_mach_thread_np(pthread_self());
6682 OS << tid << ':';
6683#endif
6684
6685 llvm::TimeRecord TR = llvm::TimeRecord::getCurrentTime();
6686 OS << llvm::format("%7.4f] ", TR.getWallTime() - sBeginTR.getWallTime());
6687 OS << Msg.str() << '\n';
6688
6689 if (Trace) {
6690 llvm::sys::PrintStackTrace(stderr);
6691 OS << "--------------------------------------------------\n";
6692 }
6693}