CIndex.cpp revision 4c9f58f617faec246d3111868ae7aee5edb9f546
1//===- 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" 17#include "CLog.h" 18#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" 25#include "SimpleFormatContext.h" 26#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" 39#include "llvm/Config/config.h" 40#include "llvm/Support/Compiler.h" 41#include "llvm/Support/CrashRecoveryContext.h" 42#include "llvm/Support/Format.h" 43#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" 52 53#if HAVE_PTHREAD_H 54#include <pthread.h> 55#endif 56 57using namespace clang; 58using namespace clang::cxcursor; 59using namespace clang::cxtu; 60using namespace clang::cxindex; 61 62CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx, ASTUnit *AU) { 63 if (!AU) 64 return 0; 65 CXTranslationUnit D = new CXTranslationUnitImpl(); 66 D->CIdx = CIdx; 67 D->TheASTUnit = AU; 68 D->StringPool = new cxstring::CXStringPool(); 69 D->Diagnostics = 0; 70 D->OverridenCursorsPool = createOverridenCXCursorsPool(); 71 D->FormatContext = 0; 72 D->FormatInMemoryUniqueId = 0; 73 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 132 CXSourceRange Result = { 133 { &SM, &LangOpts }, 134 R.getBegin().getRawEncoding(), 135 EndLoc.getRawEncoding() 136 }; 137 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)) { 167 const Decl *D = getCursorDecl(Cursor); 168 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 226bool CursorVisitor::visitFileRegion() { 227 if (RegionOfInterest.isInvalid()) 228 return false; 229 230 ASTUnit *Unit = cxtu::getASTUnit(TU); 231 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) 246 return false; 247 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()) 254 return true; // visitation break. 255 256 if (visitDeclsFromFileRegion(File, Offset, Length)) 257 return true; // visitation break. 258 259 if (!VisitDeclsOnly && VisitPreprocessorLast) 260 return visitPreprocessedEntitiesInRegion(); 261 262 return false; 263} 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 277bool CursorVisitor::visitDeclsFromFileRegion(FileID File, 278 unsigned Offset, unsigned Length) { 279 ASTUnit *Unit = cxtu::getASTUnit(TU); 280 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) 292 return false; 293 294 SourceLocation Outer; 295 if (SLEntry.isFile()) 296 Outer = SLEntry.getFile().getIncludeLoc(); 297 else 298 Outer = SLEntry.getExpansion().getExpansionLocStart(); 299 if (Outer.isInvalid()) 300 return false; 301 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; 311 SmallVector<Decl *, 16>::iterator DIt = Decls.begin(); 312 for (SmallVector<Decl *, 16>::iterator DE = Decls.end(); DIt != DE; ++DIt) { 313 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)) 343 return true; // visitation break. 344 } 345 346 if (VisitedAtLeastOnce) 347 return false; 348 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) { 362 if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true)) 363 return true; // visitation break. 364 } 365 366 DC = D->getLexicalDeclContext(); 367 } 368 369 return false; 370} 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; 429 if (!PPE) 430 continue; 431 432 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)) { 473 Decl *D = const_cast<Decl *>(getCursorDecl(Cursor)); 474 if (!D) 475 return false; 476 477 return VisitAttributes(D) || Visit(D); 478 } 479 480 if (clang_isStatement(Cursor.kind)) { 481 if (const Stmt *S = getCursorStmt(Cursor)) 482 return Visit(S); 483 484 return false; 485 } 486 487 if (clang_isExpression(Cursor.kind)) { 488 if (const Expr *E = getCursorExpr(Cursor)) 489 return Visit(E); 490 491 return false; 492 } 493 494 if (clang_isTranslationUnit(Cursor.kind)) { 495 CXTranslationUnit TU = getCursorTU(Cursor); 496 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 497 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) { 506 if (Visit(MakeCXCursor(*TL, TU, RegionOfInterest), true)) 507 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) { 524 if (const CXXBaseSpecifier *Base = getCursorCXXBaseSpecifier(Cursor)) { 525 if (TypeSourceInfo *BaseTSInfo = Base->getTypeSourceInfo()) { 526 return Visit(BaseTSInfo->getTypeLoc()); 527 } 528 } 529 } 530 531 if (Cursor.kind == CXCursor_IBOutletCollectionAttr) { 532 const IBOutletCollectionAttr *A = 533 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 539 // 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); 546 const MacroInfo *MI = 547 getMacroInfo(cxcursor::getCursorMacroDefinition(Cursor), TU); 548 if (MacroDefinition *MacroDef = 549 checkForMacroInMacroDefinition(MI, Loc, TU)) 550 return Visit(cxcursor::MakeMacroExpansionCursor(MacroDef, BeginLoc, TU)); 551 } 552 553 // 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 568Optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) { 569 if (RegionOfInterest.isValid()) { 570 SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager()); 571 if (Range.isInvalid()) 572 return None; 573 574 switch (CompareRegionOfInterest(Range)) { 575 case RangeBefore: 576 // This declaration comes before the region of interest; skip it. 577 return None; 578 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 628 const Optional<bool> &V = shouldVisitCursor(Cursor); 629 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(); 682 if (TemplateSpecializationTypeLoc TSTLoc = 683 TL.getAs<TemplateSpecializationTypeLoc>()) { 684 for (unsigned I = 0, N = TSTLoc.getNumArgs(); I != N; ++I) 685 if (VisitTemplateArgumentLoc(TSTLoc.getArgLoc(I))) 686 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) { 729 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 736 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) { 764 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 771 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(); 775 FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>(); 776 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. 780 if ((FTL && !isa<CXXConversionDecl>(ND) && Visit(FTL.getResultLoc())) || 781 (!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. 796 if (FTL && VisitFunctionTypeLoc(FTL, true)) 797 return true; 798 799 // FIXME: Attributes? 800 } 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); 1006 const Optional<bool> &V = shouldVisitCursor(Cursor); 1007 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: 1417 case BuiltinType::OCLImage1d: 1418 case BuiltinType::OCLImage1dArray: 1419 case BuiltinType::OCLImage1dBuffer: 1420 case BuiltinType::OCLImage2d: 1421 case BuiltinType::OCLImage2dArray: 1422 case BuiltinType::OCLImage3d: 1423 case BuiltinType::OCLSampler: 1424 case BuiltinType::OCLEvent: 1425#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 1549bool CursorVisitor::VisitTemplateSpecializationTypeLoc( 1550 TemplateSpecializationTypeLoc TL) { 1551 // Visit the template name. 1552 if (VisitTemplateName(TL.getTypePtr()->getTemplateName(), 1553 TL.getTemplateNameLoc())) 1554 return true; 1555 1556 // Visit the template arguments. 1557 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1558 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1559 return true; 1560 1561 return false; 1562} 1563 1564bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 1565 return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU)); 1566} 1567 1568bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 1569 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo()) 1570 return Visit(TSInfo->getTypeLoc()); 1571 1572 return false; 1573} 1574 1575bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 1576 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo()) 1577 return Visit(TSInfo->getTypeLoc()); 1578 1579 return false; 1580} 1581 1582bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 1583 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1584 return true; 1585 1586 return false; 1587} 1588 1589bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc( 1590 DependentTemplateSpecializationTypeLoc TL) { 1591 // Visit the nested-name-specifier, if there is one. 1592 if (TL.getQualifierLoc() && 1593 VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1594 return true; 1595 1596 // Visit the template arguments. 1597 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1598 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1599 return true; 1600 1601 return false; 1602} 1603 1604bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 1605 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1606 return true; 1607 1608 return Visit(TL.getNamedTypeLoc()); 1609} 1610 1611bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 1612 return Visit(TL.getPatternLoc()); 1613} 1614 1615bool CursorVisitor::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 1616 if (Expr *E = TL.getUnderlyingExpr()) 1617 return Visit(MakeCXCursor(E, StmtParent, TU)); 1618 1619 return false; 1620} 1621 1622bool CursorVisitor::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 1623 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1624} 1625 1626bool CursorVisitor::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 1627 return Visit(TL.getValueLoc()); 1628} 1629 1630#define DEFAULT_TYPELOC_IMPL(CLASS, PARENT) \ 1631bool CursorVisitor::Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { \ 1632 return Visit##PARENT##Loc(TL); \ 1633} 1634 1635DEFAULT_TYPELOC_IMPL(Complex, Type) 1636DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType) 1637DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType) 1638DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType) 1639DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType) 1640DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type) 1641DEFAULT_TYPELOC_IMPL(Vector, Type) 1642DEFAULT_TYPELOC_IMPL(ExtVector, VectorType) 1643DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType) 1644DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType) 1645DEFAULT_TYPELOC_IMPL(Record, TagType) 1646DEFAULT_TYPELOC_IMPL(Enum, TagType) 1647DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type) 1648DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type) 1649DEFAULT_TYPELOC_IMPL(Auto, Type) 1650 1651bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) { 1652 // Visit the nested-name-specifier, if present. 1653 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1654 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1655 return true; 1656 1657 if (D->isCompleteDefinition()) { 1658 for (CXXRecordDecl::base_class_iterator I = D->bases_begin(), 1659 E = D->bases_end(); I != E; ++I) { 1660 if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(I, TU))) 1661 return true; 1662 } 1663 } 1664 1665 return VisitTagDecl(D); 1666} 1667 1668bool CursorVisitor::VisitAttributes(Decl *D) { 1669 for (AttrVec::const_iterator i = D->attr_begin(), e = D->attr_end(); 1670 i != e; ++i) 1671 if (Visit(MakeCXCursor(*i, D, TU))) 1672 return true; 1673 1674 return false; 1675} 1676 1677//===----------------------------------------------------------------------===// 1678// Data-recursive visitor methods. 1679//===----------------------------------------------------------------------===// 1680 1681namespace { 1682#define DEF_JOB(NAME, DATA, KIND)\ 1683class NAME : public VisitorJob {\ 1684public:\ 1685 NAME(const DATA *d, CXCursor parent) : \ 1686 VisitorJob(parent, VisitorJob::KIND, d) {} \ 1687 static bool classof(const VisitorJob *VJ) { return VJ->getKind() == KIND; }\ 1688 const DATA *get() const { return static_cast<const DATA*>(data[0]); }\ 1689}; 1690 1691DEF_JOB(StmtVisit, Stmt, StmtVisitKind) 1692DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind) 1693DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind) 1694DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind) 1695DEF_JOB(ExplicitTemplateArgsVisit, ASTTemplateArgumentListInfo, 1696 ExplicitTemplateArgsVisitKind) 1697DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind) 1698DEF_JOB(LambdaExprParts, LambdaExpr, LambdaExprPartsKind) 1699DEF_JOB(PostChildrenVisit, void, PostChildrenVisitKind) 1700#undef DEF_JOB 1701 1702class DeclVisit : public VisitorJob { 1703public: 1704 DeclVisit(const Decl *D, CXCursor parent, bool isFirst) : 1705 VisitorJob(parent, VisitorJob::DeclVisitKind, 1706 D, isFirst ? (void*) 1 : (void*) 0) {} 1707 static bool classof(const VisitorJob *VJ) { 1708 return VJ->getKind() == DeclVisitKind; 1709 } 1710 const Decl *get() const { return static_cast<const Decl *>(data[0]); } 1711 bool isFirst() const { return data[1] ? true : false; } 1712}; 1713class TypeLocVisit : public VisitorJob { 1714public: 1715 TypeLocVisit(TypeLoc tl, CXCursor parent) : 1716 VisitorJob(parent, VisitorJob::TypeLocVisitKind, 1717 tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {} 1718 1719 static bool classof(const VisitorJob *VJ) { 1720 return VJ->getKind() == TypeLocVisitKind; 1721 } 1722 1723 TypeLoc get() const { 1724 QualType T = QualType::getFromOpaquePtr(data[0]); 1725 return TypeLoc(T, const_cast<void *>(data[1])); 1726 } 1727}; 1728 1729class LabelRefVisit : public VisitorJob { 1730public: 1731 LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent) 1732 : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD, 1733 labelLoc.getPtrEncoding()) {} 1734 1735 static bool classof(const VisitorJob *VJ) { 1736 return VJ->getKind() == VisitorJob::LabelRefVisitKind; 1737 } 1738 const LabelDecl *get() const { 1739 return static_cast<const LabelDecl *>(data[0]); 1740 } 1741 SourceLocation getLoc() const { 1742 return SourceLocation::getFromPtrEncoding(data[1]); } 1743}; 1744 1745class NestedNameSpecifierLocVisit : public VisitorJob { 1746public: 1747 NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent) 1748 : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind, 1749 Qualifier.getNestedNameSpecifier(), 1750 Qualifier.getOpaqueData()) { } 1751 1752 static bool classof(const VisitorJob *VJ) { 1753 return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind; 1754 } 1755 1756 NestedNameSpecifierLoc get() const { 1757 return NestedNameSpecifierLoc( 1758 const_cast<NestedNameSpecifier *>( 1759 static_cast<const NestedNameSpecifier *>(data[0])), 1760 const_cast<void *>(data[1])); 1761 } 1762}; 1763 1764class DeclarationNameInfoVisit : public VisitorJob { 1765public: 1766 DeclarationNameInfoVisit(const Stmt *S, CXCursor parent) 1767 : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {} 1768 static bool classof(const VisitorJob *VJ) { 1769 return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind; 1770 } 1771 DeclarationNameInfo get() const { 1772 const Stmt *S = static_cast<const Stmt *>(data[0]); 1773 switch (S->getStmtClass()) { 1774 default: 1775 llvm_unreachable("Unhandled Stmt"); 1776 case clang::Stmt::MSDependentExistsStmtClass: 1777 return cast<MSDependentExistsStmt>(S)->getNameInfo(); 1778 case Stmt::CXXDependentScopeMemberExprClass: 1779 return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo(); 1780 case Stmt::DependentScopeDeclRefExprClass: 1781 return cast<DependentScopeDeclRefExpr>(S)->getNameInfo(); 1782 } 1783 } 1784}; 1785class MemberRefVisit : public VisitorJob { 1786public: 1787 MemberRefVisit(const FieldDecl *D, SourceLocation L, CXCursor parent) 1788 : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D, 1789 L.getPtrEncoding()) {} 1790 static bool classof(const VisitorJob *VJ) { 1791 return VJ->getKind() == VisitorJob::MemberRefVisitKind; 1792 } 1793 const FieldDecl *get() const { 1794 return static_cast<const FieldDecl *>(data[0]); 1795 } 1796 SourceLocation getLoc() const { 1797 return SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[1]); 1798 } 1799}; 1800class EnqueueVisitor : public ConstStmtVisitor<EnqueueVisitor, void> { 1801 VisitorWorkList &WL; 1802 CXCursor Parent; 1803public: 1804 EnqueueVisitor(VisitorWorkList &wl, CXCursor parent) 1805 : WL(wl), Parent(parent) {} 1806 1807 void VisitAddrLabelExpr(const AddrLabelExpr *E); 1808 void VisitBlockExpr(const BlockExpr *B); 1809 void VisitCompoundLiteralExpr(const CompoundLiteralExpr *E); 1810 void VisitCompoundStmt(const CompoundStmt *S); 1811 void VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) { /* Do nothing. */ } 1812 void VisitMSDependentExistsStmt(const MSDependentExistsStmt *S); 1813 void VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E); 1814 void VisitCXXNewExpr(const CXXNewExpr *E); 1815 void VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E); 1816 void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *E); 1817 void VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E); 1818 void VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E); 1819 void VisitCXXTypeidExpr(const CXXTypeidExpr *E); 1820 void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *E); 1821 void VisitCXXUuidofExpr(const CXXUuidofExpr *E); 1822 void VisitCXXCatchStmt(const CXXCatchStmt *S); 1823 void VisitDeclRefExpr(const DeclRefExpr *D); 1824 void VisitDeclStmt(const DeclStmt *S); 1825 void VisitDependentScopeDeclRefExpr(const DependentScopeDeclRefExpr *E); 1826 void VisitDesignatedInitExpr(const DesignatedInitExpr *E); 1827 void VisitExplicitCastExpr(const ExplicitCastExpr *E); 1828 void VisitForStmt(const ForStmt *FS); 1829 void VisitGotoStmt(const GotoStmt *GS); 1830 void VisitIfStmt(const IfStmt *If); 1831 void VisitInitListExpr(const InitListExpr *IE); 1832 void VisitMemberExpr(const MemberExpr *M); 1833 void VisitOffsetOfExpr(const OffsetOfExpr *E); 1834 void VisitObjCEncodeExpr(const ObjCEncodeExpr *E); 1835 void VisitObjCMessageExpr(const ObjCMessageExpr *M); 1836 void VisitOverloadExpr(const OverloadExpr *E); 1837 void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E); 1838 void VisitStmt(const Stmt *S); 1839 void VisitSwitchStmt(const SwitchStmt *S); 1840 void VisitWhileStmt(const WhileStmt *W); 1841 void VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E); 1842 void VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *E); 1843 void VisitTypeTraitExpr(const TypeTraitExpr *E); 1844 void VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E); 1845 void VisitExpressionTraitExpr(const ExpressionTraitExpr *E); 1846 void VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U); 1847 void VisitVAArgExpr(const VAArgExpr *E); 1848 void VisitSizeOfPackExpr(const SizeOfPackExpr *E); 1849 void VisitPseudoObjectExpr(const PseudoObjectExpr *E); 1850 void VisitOpaqueValueExpr(const OpaqueValueExpr *E); 1851 void VisitLambdaExpr(const LambdaExpr *E); 1852 1853private: 1854 void AddDeclarationNameInfo(const Stmt *S); 1855 void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier); 1856 void AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A); 1857 void AddMemberRef(const FieldDecl *D, SourceLocation L); 1858 void AddStmt(const Stmt *S); 1859 void AddDecl(const Decl *D, bool isFirst = true); 1860 void AddTypeLoc(TypeSourceInfo *TI); 1861 void EnqueueChildren(const Stmt *S); 1862}; 1863} // end anonyous namespace 1864 1865void EnqueueVisitor::AddDeclarationNameInfo(const Stmt *S) { 1866 // 'S' should always be non-null, since it comes from the 1867 // statement we are visiting. 1868 WL.push_back(DeclarationNameInfoVisit(S, Parent)); 1869} 1870 1871void 1872EnqueueVisitor::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) { 1873 if (Qualifier) 1874 WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent)); 1875} 1876 1877void EnqueueVisitor::AddStmt(const Stmt *S) { 1878 if (S) 1879 WL.push_back(StmtVisit(S, Parent)); 1880} 1881void EnqueueVisitor::AddDecl(const Decl *D, bool isFirst) { 1882 if (D) 1883 WL.push_back(DeclVisit(D, Parent, isFirst)); 1884} 1885void EnqueueVisitor:: 1886 AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A) { 1887 if (A) 1888 WL.push_back(ExplicitTemplateArgsVisit(A, Parent)); 1889} 1890void EnqueueVisitor::AddMemberRef(const FieldDecl *D, SourceLocation L) { 1891 if (D) 1892 WL.push_back(MemberRefVisit(D, L, Parent)); 1893} 1894void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) { 1895 if (TI) 1896 WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent)); 1897 } 1898void EnqueueVisitor::EnqueueChildren(const Stmt *S) { 1899 unsigned size = WL.size(); 1900 for (Stmt::const_child_range Child = S->children(); Child; ++Child) { 1901 AddStmt(*Child); 1902 } 1903 if (size == WL.size()) 1904 return; 1905 // Now reverse the entries we just added. This will match the DFS 1906 // ordering performed by the worklist. 1907 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 1908 std::reverse(I, E); 1909} 1910void EnqueueVisitor::VisitAddrLabelExpr(const AddrLabelExpr *E) { 1911 WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent)); 1912} 1913void EnqueueVisitor::VisitBlockExpr(const BlockExpr *B) { 1914 AddDecl(B->getBlockDecl()); 1915} 1916void EnqueueVisitor::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) { 1917 EnqueueChildren(E); 1918 AddTypeLoc(E->getTypeSourceInfo()); 1919} 1920void EnqueueVisitor::VisitCompoundStmt(const CompoundStmt *S) { 1921 for (CompoundStmt::const_reverse_body_iterator I = S->body_rbegin(), 1922 E = S->body_rend(); I != E; ++I) { 1923 AddStmt(*I); 1924 } 1925} 1926void EnqueueVisitor:: 1927VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) { 1928 AddStmt(S->getSubStmt()); 1929 AddDeclarationNameInfo(S); 1930 if (NestedNameSpecifierLoc QualifierLoc = S->getQualifierLoc()) 1931 AddNestedNameSpecifierLoc(QualifierLoc); 1932} 1933 1934void EnqueueVisitor:: 1935VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E) { 1936 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 1937 AddDeclarationNameInfo(E); 1938 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 1939 AddNestedNameSpecifierLoc(QualifierLoc); 1940 if (!E->isImplicitAccess()) 1941 AddStmt(E->getBase()); 1942} 1943void EnqueueVisitor::VisitCXXNewExpr(const CXXNewExpr *E) { 1944 // Enqueue the initializer , if any. 1945 AddStmt(E->getInitializer()); 1946 // Enqueue the array size, if any. 1947 AddStmt(E->getArraySize()); 1948 // Enqueue the allocated type. 1949 AddTypeLoc(E->getAllocatedTypeSourceInfo()); 1950 // Enqueue the placement arguments. 1951 for (unsigned I = E->getNumPlacementArgs(); I > 0; --I) 1952 AddStmt(E->getPlacementArg(I-1)); 1953} 1954void EnqueueVisitor::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *CE) { 1955 for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I) 1956 AddStmt(CE->getArg(I-1)); 1957 AddStmt(CE->getCallee()); 1958 AddStmt(CE->getArg(0)); 1959} 1960void EnqueueVisitor::VisitCXXPseudoDestructorExpr( 1961 const CXXPseudoDestructorExpr *E) { 1962 // Visit the name of the type being destroyed. 1963 AddTypeLoc(E->getDestroyedTypeInfo()); 1964 // Visit the scope type that looks disturbingly like the nested-name-specifier 1965 // but isn't. 1966 AddTypeLoc(E->getScopeTypeInfo()); 1967 // Visit the nested-name-specifier. 1968 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 1969 AddNestedNameSpecifierLoc(QualifierLoc); 1970 // Visit base expression. 1971 AddStmt(E->getBase()); 1972} 1973void EnqueueVisitor::VisitCXXScalarValueInitExpr( 1974 const CXXScalarValueInitExpr *E) { 1975 AddTypeLoc(E->getTypeSourceInfo()); 1976} 1977void EnqueueVisitor::VisitCXXTemporaryObjectExpr( 1978 const CXXTemporaryObjectExpr *E) { 1979 EnqueueChildren(E); 1980 AddTypeLoc(E->getTypeSourceInfo()); 1981} 1982void EnqueueVisitor::VisitCXXTypeidExpr(const CXXTypeidExpr *E) { 1983 EnqueueChildren(E); 1984 if (E->isTypeOperand()) 1985 AddTypeLoc(E->getTypeOperandSourceInfo()); 1986} 1987 1988void EnqueueVisitor::VisitCXXUnresolvedConstructExpr( 1989 const CXXUnresolvedConstructExpr *E) { 1990 EnqueueChildren(E); 1991 AddTypeLoc(E->getTypeSourceInfo()); 1992} 1993void EnqueueVisitor::VisitCXXUuidofExpr(const CXXUuidofExpr *E) { 1994 EnqueueChildren(E); 1995 if (E->isTypeOperand()) 1996 AddTypeLoc(E->getTypeOperandSourceInfo()); 1997} 1998 1999void EnqueueVisitor::VisitCXXCatchStmt(const CXXCatchStmt *S) { 2000 EnqueueChildren(S); 2001 AddDecl(S->getExceptionDecl()); 2002} 2003 2004void EnqueueVisitor::VisitDeclRefExpr(const DeclRefExpr *DR) { 2005 if (DR->hasExplicitTemplateArgs()) { 2006 AddExplicitTemplateArgs(&DR->getExplicitTemplateArgs()); 2007 } 2008 WL.push_back(DeclRefExprParts(DR, Parent)); 2009} 2010void EnqueueVisitor::VisitDependentScopeDeclRefExpr( 2011 const DependentScopeDeclRefExpr *E) { 2012 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 2013 AddDeclarationNameInfo(E); 2014 AddNestedNameSpecifierLoc(E->getQualifierLoc()); 2015} 2016void EnqueueVisitor::VisitDeclStmt(const DeclStmt *S) { 2017 unsigned size = WL.size(); 2018 bool isFirst = true; 2019 for (DeclStmt::const_decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 2020 D != DEnd; ++D) { 2021 AddDecl(*D, isFirst); 2022 isFirst = false; 2023 } 2024 if (size == WL.size()) 2025 return; 2026 // Now reverse the entries we just added. This will match the DFS 2027 // ordering performed by the worklist. 2028 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 2029 std::reverse(I, E); 2030} 2031void EnqueueVisitor::VisitDesignatedInitExpr(const DesignatedInitExpr *E) { 2032 AddStmt(E->getInit()); 2033 typedef DesignatedInitExpr::Designator Designator; 2034 for (DesignatedInitExpr::const_reverse_designators_iterator 2035 D = E->designators_rbegin(), DEnd = E->designators_rend(); 2036 D != DEnd; ++D) { 2037 if (D->isFieldDesignator()) { 2038 if (FieldDecl *Field = D->getField()) 2039 AddMemberRef(Field, D->getFieldLoc()); 2040 continue; 2041 } 2042 if (D->isArrayDesignator()) { 2043 AddStmt(E->getArrayIndex(*D)); 2044 continue; 2045 } 2046 assert(D->isArrayRangeDesignator() && "Unknown designator kind"); 2047 AddStmt(E->getArrayRangeEnd(*D)); 2048 AddStmt(E->getArrayRangeStart(*D)); 2049 } 2050} 2051void EnqueueVisitor::VisitExplicitCastExpr(const ExplicitCastExpr *E) { 2052 EnqueueChildren(E); 2053 AddTypeLoc(E->getTypeInfoAsWritten()); 2054} 2055void EnqueueVisitor::VisitForStmt(const ForStmt *FS) { 2056 AddStmt(FS->getBody()); 2057 AddStmt(FS->getInc()); 2058 AddStmt(FS->getCond()); 2059 AddDecl(FS->getConditionVariable()); 2060 AddStmt(FS->getInit()); 2061} 2062void EnqueueVisitor::VisitGotoStmt(const GotoStmt *GS) { 2063 WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent)); 2064} 2065void EnqueueVisitor::VisitIfStmt(const IfStmt *If) { 2066 AddStmt(If->getElse()); 2067 AddStmt(If->getThen()); 2068 AddStmt(If->getCond()); 2069 AddDecl(If->getConditionVariable()); 2070} 2071void EnqueueVisitor::VisitInitListExpr(const InitListExpr *IE) { 2072 // We care about the syntactic form of the initializer list, only. 2073 if (InitListExpr *Syntactic = IE->getSyntacticForm()) 2074 IE = Syntactic; 2075 EnqueueChildren(IE); 2076} 2077void EnqueueVisitor::VisitMemberExpr(const MemberExpr *M) { 2078 WL.push_back(MemberExprParts(M, Parent)); 2079 2080 // If the base of the member access expression is an implicit 'this', don't 2081 // visit it. 2082 // FIXME: If we ever want to show these implicit accesses, this will be 2083 // unfortunate. However, clang_getCursor() relies on this behavior. 2084 if (!M->isImplicitAccess()) 2085 AddStmt(M->getBase()); 2086} 2087void EnqueueVisitor::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { 2088 AddTypeLoc(E->getEncodedTypeSourceInfo()); 2089} 2090void EnqueueVisitor::VisitObjCMessageExpr(const ObjCMessageExpr *M) { 2091 EnqueueChildren(M); 2092 AddTypeLoc(M->getClassReceiverTypeInfo()); 2093} 2094void EnqueueVisitor::VisitOffsetOfExpr(const OffsetOfExpr *E) { 2095 // Visit the components of the offsetof expression. 2096 for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) { 2097 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode; 2098 const OffsetOfNode &Node = E->getComponent(I-1); 2099 switch (Node.getKind()) { 2100 case OffsetOfNode::Array: 2101 AddStmt(E->getIndexExpr(Node.getArrayExprIndex())); 2102 break; 2103 case OffsetOfNode::Field: 2104 AddMemberRef(Node.getField(), Node.getSourceRange().getEnd()); 2105 break; 2106 case OffsetOfNode::Identifier: 2107 case OffsetOfNode::Base: 2108 continue; 2109 } 2110 } 2111 // Visit the type into which we're computing the offset. 2112 AddTypeLoc(E->getTypeSourceInfo()); 2113} 2114void EnqueueVisitor::VisitOverloadExpr(const OverloadExpr *E) { 2115 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 2116 WL.push_back(OverloadExprParts(E, Parent)); 2117} 2118void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr( 2119 const UnaryExprOrTypeTraitExpr *E) { 2120 EnqueueChildren(E); 2121 if (E->isArgumentType()) 2122 AddTypeLoc(E->getArgumentTypeInfo()); 2123} 2124void EnqueueVisitor::VisitStmt(const Stmt *S) { 2125 EnqueueChildren(S); 2126} 2127void EnqueueVisitor::VisitSwitchStmt(const SwitchStmt *S) { 2128 AddStmt(S->getBody()); 2129 AddStmt(S->getCond()); 2130 AddDecl(S->getConditionVariable()); 2131} 2132 2133void EnqueueVisitor::VisitWhileStmt(const WhileStmt *W) { 2134 AddStmt(W->getBody()); 2135 AddStmt(W->getCond()); 2136 AddDecl(W->getConditionVariable()); 2137} 2138 2139void EnqueueVisitor::VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 2140 AddTypeLoc(E->getQueriedTypeSourceInfo()); 2141} 2142 2143void EnqueueVisitor::VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *E) { 2144 AddTypeLoc(E->getRhsTypeSourceInfo()); 2145 AddTypeLoc(E->getLhsTypeSourceInfo()); 2146} 2147 2148void EnqueueVisitor::VisitTypeTraitExpr(const TypeTraitExpr *E) { 2149 for (unsigned I = E->getNumArgs(); I > 0; --I) 2150 AddTypeLoc(E->getArg(I-1)); 2151} 2152 2153void EnqueueVisitor::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) { 2154 AddTypeLoc(E->getQueriedTypeSourceInfo()); 2155} 2156 2157void EnqueueVisitor::VisitExpressionTraitExpr(const ExpressionTraitExpr *E) { 2158 EnqueueChildren(E); 2159} 2160 2161void EnqueueVisitor::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U) { 2162 VisitOverloadExpr(U); 2163 if (!U->isImplicitAccess()) 2164 AddStmt(U->getBase()); 2165} 2166void EnqueueVisitor::VisitVAArgExpr(const VAArgExpr *E) { 2167 AddStmt(E->getSubExpr()); 2168 AddTypeLoc(E->getWrittenTypeInfo()); 2169} 2170void EnqueueVisitor::VisitSizeOfPackExpr(const SizeOfPackExpr *E) { 2171 WL.push_back(SizeOfPackExprParts(E, Parent)); 2172} 2173void EnqueueVisitor::VisitOpaqueValueExpr(const OpaqueValueExpr *E) { 2174 // If the opaque value has a source expression, just transparently 2175 // visit that. This is useful for (e.g.) pseudo-object expressions. 2176 if (Expr *SourceExpr = E->getSourceExpr()) 2177 return Visit(SourceExpr); 2178} 2179void EnqueueVisitor::VisitLambdaExpr(const LambdaExpr *E) { 2180 AddStmt(E->getBody()); 2181 WL.push_back(LambdaExprParts(E, Parent)); 2182} 2183void EnqueueVisitor::VisitPseudoObjectExpr(const PseudoObjectExpr *E) { 2184 // Treat the expression like its syntactic form. 2185 Visit(E->getSyntacticForm()); 2186} 2187 2188void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) { 2189 EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S); 2190} 2191 2192bool CursorVisitor::IsInRegionOfInterest(CXCursor C) { 2193 if (RegionOfInterest.isValid()) { 2194 SourceRange Range = getRawCursorExtent(C); 2195 if (Range.isInvalid() || CompareRegionOfInterest(Range)) 2196 return false; 2197 } 2198 return true; 2199} 2200 2201bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) { 2202 while (!WL.empty()) { 2203 // Dequeue the worklist item. 2204 VisitorJob LI = WL.back(); 2205 WL.pop_back(); 2206 2207 // Set the Parent field, then back to its old value once we're done. 2208 SetParentRAII SetParent(Parent, StmtParent, LI.getParent()); 2209 2210 switch (LI.getKind()) { 2211 case VisitorJob::DeclVisitKind: { 2212 const Decl *D = cast<DeclVisit>(&LI)->get(); 2213 if (!D) 2214 continue; 2215 2216 // For now, perform default visitation for Decls. 2217 if (Visit(MakeCXCursor(D, TU, RegionOfInterest, 2218 cast<DeclVisit>(&LI)->isFirst()))) 2219 return true; 2220 2221 continue; 2222 } 2223 case VisitorJob::ExplicitTemplateArgsVisitKind: { 2224 const ASTTemplateArgumentListInfo *ArgList = 2225 cast<ExplicitTemplateArgsVisit>(&LI)->get(); 2226 for (const TemplateArgumentLoc *Arg = ArgList->getTemplateArgs(), 2227 *ArgEnd = Arg + ArgList->NumTemplateArgs; 2228 Arg != ArgEnd; ++Arg) { 2229 if (VisitTemplateArgumentLoc(*Arg)) 2230 return true; 2231 } 2232 continue; 2233 } 2234 case VisitorJob::TypeLocVisitKind: { 2235 // Perform default visitation for TypeLocs. 2236 if (Visit(cast<TypeLocVisit>(&LI)->get())) 2237 return true; 2238 continue; 2239 } 2240 case VisitorJob::LabelRefVisitKind: { 2241 const LabelDecl *LS = cast<LabelRefVisit>(&LI)->get(); 2242 if (LabelStmt *stmt = LS->getStmt()) { 2243 if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(), 2244 TU))) { 2245 return true; 2246 } 2247 } 2248 continue; 2249 } 2250 2251 case VisitorJob::NestedNameSpecifierLocVisitKind: { 2252 NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI); 2253 if (VisitNestedNameSpecifierLoc(V->get())) 2254 return true; 2255 continue; 2256 } 2257 2258 case VisitorJob::DeclarationNameInfoVisitKind: { 2259 if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI) 2260 ->get())) 2261 return true; 2262 continue; 2263 } 2264 case VisitorJob::MemberRefVisitKind: { 2265 MemberRefVisit *V = cast<MemberRefVisit>(&LI); 2266 if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU))) 2267 return true; 2268 continue; 2269 } 2270 case VisitorJob::StmtVisitKind: { 2271 const Stmt *S = cast<StmtVisit>(&LI)->get(); 2272 if (!S) 2273 continue; 2274 2275 // Update the current cursor. 2276 CXCursor Cursor = MakeCXCursor(S, StmtParent, TU, RegionOfInterest); 2277 if (!IsInRegionOfInterest(Cursor)) 2278 continue; 2279 switch (Visitor(Cursor, Parent, ClientData)) { 2280 case CXChildVisit_Break: return true; 2281 case CXChildVisit_Continue: break; 2282 case CXChildVisit_Recurse: 2283 if (PostChildrenVisitor) 2284 WL.push_back(PostChildrenVisit(0, Cursor)); 2285 EnqueueWorkList(WL, S); 2286 break; 2287 } 2288 continue; 2289 } 2290 case VisitorJob::MemberExprPartsKind: { 2291 // Handle the other pieces in the MemberExpr besides the base. 2292 const MemberExpr *M = cast<MemberExprParts>(&LI)->get(); 2293 2294 // Visit the nested-name-specifier 2295 if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc()) 2296 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2297 return true; 2298 2299 // Visit the declaration name. 2300 if (VisitDeclarationNameInfo(M->getMemberNameInfo())) 2301 return true; 2302 2303 // Visit the explicitly-specified template arguments, if any. 2304 if (M->hasExplicitTemplateArgs()) { 2305 for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(), 2306 *ArgEnd = Arg + M->getNumTemplateArgs(); 2307 Arg != ArgEnd; ++Arg) { 2308 if (VisitTemplateArgumentLoc(*Arg)) 2309 return true; 2310 } 2311 } 2312 continue; 2313 } 2314 case VisitorJob::DeclRefExprPartsKind: { 2315 const DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get(); 2316 // Visit nested-name-specifier, if present. 2317 if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc()) 2318 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2319 return true; 2320 // Visit declaration name. 2321 if (VisitDeclarationNameInfo(DR->getNameInfo())) 2322 return true; 2323 continue; 2324 } 2325 case VisitorJob::OverloadExprPartsKind: { 2326 const OverloadExpr *O = cast<OverloadExprParts>(&LI)->get(); 2327 // Visit the nested-name-specifier. 2328 if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc()) 2329 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2330 return true; 2331 // Visit the declaration name. 2332 if (VisitDeclarationNameInfo(O->getNameInfo())) 2333 return true; 2334 // Visit the overloaded declaration reference. 2335 if (Visit(MakeCursorOverloadedDeclRef(O, TU))) 2336 return true; 2337 continue; 2338 } 2339 case VisitorJob::SizeOfPackExprPartsKind: { 2340 const SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get(); 2341 NamedDecl *Pack = E->getPack(); 2342 if (isa<TemplateTypeParmDecl>(Pack)) { 2343 if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack), 2344 E->getPackLoc(), TU))) 2345 return true; 2346 2347 continue; 2348 } 2349 2350 if (isa<TemplateTemplateParmDecl>(Pack)) { 2351 if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack), 2352 E->getPackLoc(), TU))) 2353 return true; 2354 2355 continue; 2356 } 2357 2358 // Non-type template parameter packs and function parameter packs are 2359 // treated like DeclRefExpr cursors. 2360 continue; 2361 } 2362 2363 case VisitorJob::LambdaExprPartsKind: { 2364 // Visit captures. 2365 const LambdaExpr *E = cast<LambdaExprParts>(&LI)->get(); 2366 for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(), 2367 CEnd = E->explicit_capture_end(); 2368 C != CEnd; ++C) { 2369 // FIXME: Lambda init-captures. 2370 if (!C->capturesVariable()) 2371 continue; 2372 2373 if (Visit(MakeCursorVariableRef(C->getCapturedVar(), 2374 C->getLocation(), 2375 TU))) 2376 return true; 2377 } 2378 2379 // Visit parameters and return type, if present. 2380 if (E->hasExplicitParameters() || E->hasExplicitResultType()) { 2381 TypeLoc TL = E->getCallOperator()->getTypeSourceInfo()->getTypeLoc(); 2382 if (E->hasExplicitParameters() && E->hasExplicitResultType()) { 2383 // Visit the whole type. 2384 if (Visit(TL)) 2385 return true; 2386 } else if (FunctionProtoTypeLoc Proto = 2387 TL.getAs<FunctionProtoTypeLoc>()) { 2388 if (E->hasExplicitParameters()) { 2389 // Visit parameters. 2390 for (unsigned I = 0, N = Proto.getNumArgs(); I != N; ++I) 2391 if (Visit(MakeCXCursor(Proto.getArg(I), TU))) 2392 return true; 2393 } else { 2394 // Visit result type. 2395 if (Visit(Proto.getResultLoc())) 2396 return true; 2397 } 2398 } 2399 } 2400 break; 2401 } 2402 2403 case VisitorJob::PostChildrenVisitKind: 2404 if (PostChildrenVisitor(Parent, ClientData)) 2405 return true; 2406 break; 2407 } 2408 } 2409 return false; 2410} 2411 2412bool CursorVisitor::Visit(const Stmt *S) { 2413 VisitorWorkList *WL = 0; 2414 if (!WorkListFreeList.empty()) { 2415 WL = WorkListFreeList.back(); 2416 WL->clear(); 2417 WorkListFreeList.pop_back(); 2418 } 2419 else { 2420 WL = new VisitorWorkList(); 2421 WorkListCache.push_back(WL); 2422 } 2423 EnqueueWorkList(*WL, S); 2424 bool result = RunVisitorWorkList(*WL); 2425 WorkListFreeList.push_back(WL); 2426 return result; 2427} 2428 2429namespace { 2430typedef SmallVector<SourceRange, 4> RefNamePieces; 2431RefNamePieces buildPieces(unsigned NameFlags, bool IsMemberRefExpr, 2432 const DeclarationNameInfo &NI, 2433 const SourceRange &QLoc, 2434 const ASTTemplateArgumentListInfo *TemplateArgs = 0){ 2435 const bool WantQualifier = NameFlags & CXNameRange_WantQualifier; 2436 const bool WantTemplateArgs = NameFlags & CXNameRange_WantTemplateArgs; 2437 const bool WantSinglePiece = NameFlags & CXNameRange_WantSinglePiece; 2438 2439 const DeclarationName::NameKind Kind = NI.getName().getNameKind(); 2440 2441 RefNamePieces Pieces; 2442 2443 if (WantQualifier && QLoc.isValid()) 2444 Pieces.push_back(QLoc); 2445 2446 if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr) 2447 Pieces.push_back(NI.getLoc()); 2448 2449 if (WantTemplateArgs && TemplateArgs) 2450 Pieces.push_back(SourceRange(TemplateArgs->LAngleLoc, 2451 TemplateArgs->RAngleLoc)); 2452 2453 if (Kind == DeclarationName::CXXOperatorName) { 2454 Pieces.push_back(SourceLocation::getFromRawEncoding( 2455 NI.getInfo().CXXOperatorName.BeginOpNameLoc)); 2456 Pieces.push_back(SourceLocation::getFromRawEncoding( 2457 NI.getInfo().CXXOperatorName.EndOpNameLoc)); 2458 } 2459 2460 if (WantSinglePiece) { 2461 SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd()); 2462 Pieces.clear(); 2463 Pieces.push_back(R); 2464 } 2465 2466 return Pieces; 2467} 2468} 2469 2470//===----------------------------------------------------------------------===// 2471// Misc. API hooks. 2472//===----------------------------------------------------------------------===// 2473 2474static llvm::sys::Mutex EnableMultithreadingMutex; 2475static bool EnabledMultithreading; 2476 2477static void fatal_error_handler(void *user_data, const std::string& reason, 2478 bool gen_crash_diag) { 2479 // Write the result out to stderr avoiding errs() because raw_ostreams can 2480 // call report_fatal_error. 2481 fprintf(stderr, "LIBCLANG FATAL ERROR: %s\n", reason.c_str()); 2482 ::abort(); 2483} 2484 2485extern "C" { 2486CXIndex clang_createIndex(int excludeDeclarationsFromPCH, 2487 int displayDiagnostics) { 2488 // Disable pretty stack trace functionality, which will otherwise be a very 2489 // poor citizen of the world and set up all sorts of signal handlers. 2490 llvm::DisablePrettyStackTrace = true; 2491 2492 // We use crash recovery to make some of our APIs more reliable, implicitly 2493 // enable it. 2494 llvm::CrashRecoveryContext::Enable(); 2495 2496 // Enable support for multithreading in LLVM. 2497 { 2498 llvm::sys::ScopedLock L(EnableMultithreadingMutex); 2499 if (!EnabledMultithreading) { 2500 llvm::install_fatal_error_handler(fatal_error_handler, 0); 2501 llvm::llvm_start_multithreaded(); 2502 EnabledMultithreading = true; 2503 } 2504 } 2505 2506 CIndexer *CIdxr = new CIndexer(); 2507 if (excludeDeclarationsFromPCH) 2508 CIdxr->setOnlyLocalDecls(); 2509 if (displayDiagnostics) 2510 CIdxr->setDisplayDiagnostics(); 2511 2512 if (getenv("LIBCLANG_BGPRIO_INDEX")) 2513 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() | 2514 CXGlobalOpt_ThreadBackgroundPriorityForIndexing); 2515 if (getenv("LIBCLANG_BGPRIO_EDIT")) 2516 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() | 2517 CXGlobalOpt_ThreadBackgroundPriorityForEditing); 2518 2519 return CIdxr; 2520} 2521 2522void clang_disposeIndex(CXIndex CIdx) { 2523 if (CIdx) 2524 delete static_cast<CIndexer *>(CIdx); 2525} 2526 2527void clang_CXIndex_setGlobalOptions(CXIndex CIdx, unsigned options) { 2528 if (CIdx) 2529 static_cast<CIndexer *>(CIdx)->setCXGlobalOptFlags(options); 2530} 2531 2532unsigned clang_CXIndex_getGlobalOptions(CXIndex CIdx) { 2533 if (CIdx) 2534 return static_cast<CIndexer *>(CIdx)->getCXGlobalOptFlags(); 2535 return 0; 2536} 2537 2538void clang_toggleCrashRecovery(unsigned isEnabled) { 2539 if (isEnabled) 2540 llvm::CrashRecoveryContext::Enable(); 2541 else 2542 llvm::CrashRecoveryContext::Disable(); 2543} 2544 2545CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx, 2546 const char *ast_filename) { 2547 if (!CIdx || !ast_filename) 2548 return 0; 2549 2550 LOG_FUNC_SECTION { 2551 *Log << ast_filename; 2552 } 2553 2554 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 2555 FileSystemOptions FileSystemOpts; 2556 2557 IntrusiveRefCntPtr<DiagnosticsEngine> Diags; 2558 ASTUnit *TU = ASTUnit::LoadFromASTFile(ast_filename, Diags, FileSystemOpts, 2559 CXXIdx->getOnlyLocalDecls(), 2560 0, 0, 2561 /*CaptureDiagnostics=*/true, 2562 /*AllowPCHWithCompilerErrors=*/true, 2563 /*UserFilesAreVolatile=*/true); 2564 return MakeCXTranslationUnit(CXXIdx, TU); 2565} 2566 2567unsigned clang_defaultEditingTranslationUnitOptions() { 2568 return CXTranslationUnit_PrecompiledPreamble | 2569 CXTranslationUnit_CacheCompletionResults; 2570} 2571 2572CXTranslationUnit 2573clang_createTranslationUnitFromSourceFile(CXIndex CIdx, 2574 const char *source_filename, 2575 int num_command_line_args, 2576 const char * const *command_line_args, 2577 unsigned num_unsaved_files, 2578 struct CXUnsavedFile *unsaved_files) { 2579 unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord; 2580 return clang_parseTranslationUnit(CIdx, source_filename, 2581 command_line_args, num_command_line_args, 2582 unsaved_files, num_unsaved_files, 2583 Options); 2584} 2585 2586struct ParseTranslationUnitInfo { 2587 CXIndex CIdx; 2588 const char *source_filename; 2589 const char *const *command_line_args; 2590 int num_command_line_args; 2591 struct CXUnsavedFile *unsaved_files; 2592 unsigned num_unsaved_files; 2593 unsigned options; 2594 CXTranslationUnit result; 2595}; 2596static void clang_parseTranslationUnit_Impl(void *UserData) { 2597 ParseTranslationUnitInfo *PTUI = 2598 static_cast<ParseTranslationUnitInfo*>(UserData); 2599 CXIndex CIdx = PTUI->CIdx; 2600 const char *source_filename = PTUI->source_filename; 2601 const char * const *command_line_args = PTUI->command_line_args; 2602 int num_command_line_args = PTUI->num_command_line_args; 2603 struct CXUnsavedFile *unsaved_files = PTUI->unsaved_files; 2604 unsigned num_unsaved_files = PTUI->num_unsaved_files; 2605 unsigned options = PTUI->options; 2606 PTUI->result = 0; 2607 2608 if (!CIdx) 2609 return; 2610 2611 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 2612 2613 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing)) 2614 setThreadBackgroundPriority(); 2615 2616 bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble; 2617 // FIXME: Add a flag for modules. 2618 TranslationUnitKind TUKind 2619 = (options & CXTranslationUnit_Incomplete)? TU_Prefix : TU_Complete; 2620 bool CacheCodeCompetionResults 2621 = options & CXTranslationUnit_CacheCompletionResults; 2622 bool IncludeBriefCommentsInCodeCompletion 2623 = options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion; 2624 bool SkipFunctionBodies = options & CXTranslationUnit_SkipFunctionBodies; 2625 bool ForSerialization = options & CXTranslationUnit_ForSerialization; 2626 2627 // Configure the diagnostics. 2628 IntrusiveRefCntPtr<DiagnosticsEngine> 2629 Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions)); 2630 2631 // Recover resources if we crash before exiting this function. 2632 llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine, 2633 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> > 2634 DiagCleanup(Diags.getPtr()); 2635 2636 OwningPtr<std::vector<ASTUnit::RemappedFile> > 2637 RemappedFiles(new std::vector<ASTUnit::RemappedFile>()); 2638 2639 // Recover resources if we crash before exiting this function. 2640 llvm::CrashRecoveryContextCleanupRegistrar< 2641 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get()); 2642 2643 for (unsigned I = 0; I != num_unsaved_files; ++I) { 2644 StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length); 2645 const llvm::MemoryBuffer *Buffer 2646 = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename); 2647 RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename, 2648 Buffer)); 2649 } 2650 2651 OwningPtr<std::vector<const char *> > 2652 Args(new std::vector<const char*>()); 2653 2654 // Recover resources if we crash before exiting this method. 2655 llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> > 2656 ArgsCleanup(Args.get()); 2657 2658 // Since the Clang C library is primarily used by batch tools dealing with 2659 // (often very broken) source code, where spell-checking can have a 2660 // significant negative impact on performance (particularly when 2661 // precompiled headers are involved), we disable it by default. 2662 // Only do this if we haven't found a spell-checking-related argument. 2663 bool FoundSpellCheckingArgument = false; 2664 for (int I = 0; I != num_command_line_args; ++I) { 2665 if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 || 2666 strcmp(command_line_args[I], "-fspell-checking") == 0) { 2667 FoundSpellCheckingArgument = true; 2668 break; 2669 } 2670 } 2671 if (!FoundSpellCheckingArgument) 2672 Args->push_back("-fno-spell-checking"); 2673 2674 Args->insert(Args->end(), command_line_args, 2675 command_line_args + num_command_line_args); 2676 2677 // The 'source_filename' argument is optional. If the caller does not 2678 // specify it then it is assumed that the source file is specified 2679 // in the actual argument list. 2680 // Put the source file after command_line_args otherwise if '-x' flag is 2681 // present it will be unused. 2682 if (source_filename) 2683 Args->push_back(source_filename); 2684 2685 // Do we need the detailed preprocessing record? 2686 if (options & CXTranslationUnit_DetailedPreprocessingRecord) { 2687 Args->push_back("-Xclang"); 2688 Args->push_back("-detailed-preprocessing-record"); 2689 } 2690 2691 unsigned NumErrors = Diags->getClient()->getNumErrors(); 2692 OwningPtr<ASTUnit> ErrUnit; 2693 OwningPtr<ASTUnit> Unit( 2694 ASTUnit::LoadFromCommandLine(Args->size() ? &(*Args)[0] : 0 2695 /* vector::data() not portable */, 2696 Args->size() ? (&(*Args)[0] + Args->size()) :0, 2697 Diags, 2698 CXXIdx->getClangResourcesPath(), 2699 CXXIdx->getOnlyLocalDecls(), 2700 /*CaptureDiagnostics=*/true, 2701 RemappedFiles->size() ? &(*RemappedFiles)[0]:0, 2702 RemappedFiles->size(), 2703 /*RemappedFilesKeepOriginalName=*/true, 2704 PrecompilePreamble, 2705 TUKind, 2706 CacheCodeCompetionResults, 2707 IncludeBriefCommentsInCodeCompletion, 2708 /*AllowPCHWithCompilerErrors=*/true, 2709 SkipFunctionBodies, 2710 /*UserFilesAreVolatile=*/true, 2711 ForSerialization, 2712 &ErrUnit)); 2713 2714 if (NumErrors != Diags->getClient()->getNumErrors()) { 2715 // Make sure to check that 'Unit' is non-NULL. 2716 if (CXXIdx->getDisplayDiagnostics()) 2717 printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get()); 2718 } 2719 2720 PTUI->result = MakeCXTranslationUnit(CXXIdx, Unit.take()); 2721} 2722CXTranslationUnit clang_parseTranslationUnit(CXIndex CIdx, 2723 const char *source_filename, 2724 const char * const *command_line_args, 2725 int num_command_line_args, 2726 struct CXUnsavedFile *unsaved_files, 2727 unsigned num_unsaved_files, 2728 unsigned options) { 2729 LOG_FUNC_SECTION { 2730 *Log << source_filename << ": "; 2731 for (int i = 0; i != num_command_line_args; ++i) 2732 *Log << command_line_args[i] << " "; 2733 } 2734 2735 ParseTranslationUnitInfo PTUI = { CIdx, source_filename, command_line_args, 2736 num_command_line_args, unsaved_files, 2737 num_unsaved_files, options, 0 }; 2738 llvm::CrashRecoveryContext CRC; 2739 2740 if (!RunSafely(CRC, clang_parseTranslationUnit_Impl, &PTUI)) { 2741 fprintf(stderr, "libclang: crash detected during parsing: {\n"); 2742 fprintf(stderr, " 'source_filename' : '%s'\n", source_filename); 2743 fprintf(stderr, " 'command_line_args' : ["); 2744 for (int i = 0; i != num_command_line_args; ++i) { 2745 if (i) 2746 fprintf(stderr, ", "); 2747 fprintf(stderr, "'%s'", command_line_args[i]); 2748 } 2749 fprintf(stderr, "],\n"); 2750 fprintf(stderr, " 'unsaved_files' : ["); 2751 for (unsigned i = 0; i != num_unsaved_files; ++i) { 2752 if (i) 2753 fprintf(stderr, ", "); 2754 fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename, 2755 unsaved_files[i].Length); 2756 } 2757 fprintf(stderr, "],\n"); 2758 fprintf(stderr, " 'options' : %d,\n", options); 2759 fprintf(stderr, "}\n"); 2760 2761 return 0; 2762 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) { 2763 PrintLibclangResourceUsage(PTUI.result); 2764 } 2765 2766 return PTUI.result; 2767} 2768 2769unsigned clang_defaultSaveOptions(CXTranslationUnit TU) { 2770 return CXSaveTranslationUnit_None; 2771} 2772 2773namespace { 2774 2775struct SaveTranslationUnitInfo { 2776 CXTranslationUnit TU; 2777 const char *FileName; 2778 unsigned options; 2779 CXSaveError result; 2780}; 2781 2782} 2783 2784static void clang_saveTranslationUnit_Impl(void *UserData) { 2785 SaveTranslationUnitInfo *STUI = 2786 static_cast<SaveTranslationUnitInfo*>(UserData); 2787 2788 CIndexer *CXXIdx = STUI->TU->CIdx; 2789 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing)) 2790 setThreadBackgroundPriority(); 2791 2792 bool hadError = cxtu::getASTUnit(STUI->TU)->Save(STUI->FileName); 2793 STUI->result = hadError ? CXSaveError_Unknown : CXSaveError_None; 2794} 2795 2796int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName, 2797 unsigned options) { 2798 LOG_FUNC_SECTION { 2799 *Log << TU << ' ' << FileName; 2800 } 2801 2802 if (!TU) 2803 return CXSaveError_InvalidTU; 2804 2805 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 2806 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 2807 if (!CXXUnit->hasSema()) 2808 return CXSaveError_InvalidTU; 2809 2810 SaveTranslationUnitInfo STUI = { TU, FileName, options, CXSaveError_None }; 2811 2812 if (!CXXUnit->getDiagnostics().hasUnrecoverableErrorOccurred() || 2813 getenv("LIBCLANG_NOTHREADS")) { 2814 clang_saveTranslationUnit_Impl(&STUI); 2815 2816 if (getenv("LIBCLANG_RESOURCE_USAGE")) 2817 PrintLibclangResourceUsage(TU); 2818 2819 return STUI.result; 2820 } 2821 2822 // We have an AST that has invalid nodes due to compiler errors. 2823 // Use a crash recovery thread for protection. 2824 2825 llvm::CrashRecoveryContext CRC; 2826 2827 if (!RunSafely(CRC, clang_saveTranslationUnit_Impl, &STUI)) { 2828 fprintf(stderr, "libclang: crash detected during AST saving: {\n"); 2829 fprintf(stderr, " 'filename' : '%s'\n", FileName); 2830 fprintf(stderr, " 'options' : %d,\n", options); 2831 fprintf(stderr, "}\n"); 2832 2833 return CXSaveError_Unknown; 2834 2835 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) { 2836 PrintLibclangResourceUsage(TU); 2837 } 2838 2839 return STUI.result; 2840} 2841 2842void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) { 2843 if (CTUnit) { 2844 // If the translation unit has been marked as unsafe to free, just discard 2845 // it. 2846 if (cxtu::getASTUnit(CTUnit)->isUnsafeToFree()) 2847 return; 2848 2849 delete cxtu::getASTUnit(CTUnit); 2850 delete CTUnit->StringPool; 2851 delete static_cast<CXDiagnosticSetImpl *>(CTUnit->Diagnostics); 2852 disposeOverridenCXCursorsPool(CTUnit->OverridenCursorsPool); 2853 delete CTUnit->FormatContext; 2854 delete CTUnit; 2855 } 2856} 2857 2858unsigned clang_defaultReparseOptions(CXTranslationUnit TU) { 2859 return CXReparse_None; 2860} 2861 2862struct ReparseTranslationUnitInfo { 2863 CXTranslationUnit TU; 2864 unsigned num_unsaved_files; 2865 struct CXUnsavedFile *unsaved_files; 2866 unsigned options; 2867 int result; 2868}; 2869 2870static void clang_reparseTranslationUnit_Impl(void *UserData) { 2871 ReparseTranslationUnitInfo *RTUI = 2872 static_cast<ReparseTranslationUnitInfo*>(UserData); 2873 CXTranslationUnit TU = RTUI->TU; 2874 if (!TU) 2875 return; 2876 2877 // Reset the associated diagnostics. 2878 delete static_cast<CXDiagnosticSetImpl*>(TU->Diagnostics); 2879 TU->Diagnostics = 0; 2880 2881 unsigned num_unsaved_files = RTUI->num_unsaved_files; 2882 struct CXUnsavedFile *unsaved_files = RTUI->unsaved_files; 2883 unsigned options = RTUI->options; 2884 (void) options; 2885 RTUI->result = 1; 2886 2887 CIndexer *CXXIdx = TU->CIdx; 2888 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 2889 setThreadBackgroundPriority(); 2890 2891 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 2892 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 2893 2894 OwningPtr<std::vector<ASTUnit::RemappedFile> > 2895 RemappedFiles(new std::vector<ASTUnit::RemappedFile>()); 2896 2897 // Recover resources if we crash before exiting this function. 2898 llvm::CrashRecoveryContextCleanupRegistrar< 2899 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get()); 2900 2901 for (unsigned I = 0; I != num_unsaved_files; ++I) { 2902 StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length); 2903 const llvm::MemoryBuffer *Buffer 2904 = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename); 2905 RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename, 2906 Buffer)); 2907 } 2908 2909 if (!CXXUnit->Reparse(RemappedFiles->size() ? &(*RemappedFiles)[0] : 0, 2910 RemappedFiles->size())) 2911 RTUI->result = 0; 2912} 2913 2914int clang_reparseTranslationUnit(CXTranslationUnit TU, 2915 unsigned num_unsaved_files, 2916 struct CXUnsavedFile *unsaved_files, 2917 unsigned options) { 2918 LOG_FUNC_SECTION { 2919 *Log << TU; 2920 } 2921 2922 ReparseTranslationUnitInfo RTUI = { TU, num_unsaved_files, unsaved_files, 2923 options, 0 }; 2924 2925 if (getenv("LIBCLANG_NOTHREADS")) { 2926 clang_reparseTranslationUnit_Impl(&RTUI); 2927 return RTUI.result; 2928 } 2929 2930 llvm::CrashRecoveryContext CRC; 2931 2932 if (!RunSafely(CRC, clang_reparseTranslationUnit_Impl, &RTUI)) { 2933 fprintf(stderr, "libclang: crash detected during reparsing\n"); 2934 cxtu::getASTUnit(TU)->setUnsafeToFree(true); 2935 return 1; 2936 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) 2937 PrintLibclangResourceUsage(TU); 2938 2939 return RTUI.result; 2940} 2941 2942 2943CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) { 2944 if (!CTUnit) 2945 return cxstring::createEmpty(); 2946 2947 ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit); 2948 return cxstring::createDup(CXXUnit->getOriginalSourceFileName()); 2949} 2950 2951CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) { 2952 if (!TU) 2953 return clang_getNullCursor(); 2954 2955 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 2956 return MakeCXCursor(CXXUnit->getASTContext().getTranslationUnitDecl(), TU); 2957} 2958 2959} // end: extern "C" 2960 2961//===----------------------------------------------------------------------===// 2962// CXFile Operations. 2963//===----------------------------------------------------------------------===// 2964 2965extern "C" { 2966CXString clang_getFileName(CXFile SFile) { 2967 if (!SFile) 2968 return cxstring::createNull(); 2969 2970 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 2971 return cxstring::createRef(FEnt->getName()); 2972} 2973 2974time_t clang_getFileTime(CXFile SFile) { 2975 if (!SFile) 2976 return 0; 2977 2978 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 2979 return FEnt->getModificationTime(); 2980} 2981 2982CXFile clang_getFile(CXTranslationUnit TU, const char *file_name) { 2983 if (!TU) 2984 return 0; 2985 2986 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 2987 2988 FileManager &FMgr = CXXUnit->getFileManager(); 2989 return const_cast<FileEntry *>(FMgr.getFile(file_name)); 2990} 2991 2992unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit TU, CXFile file) { 2993 if (!TU || !file) 2994 return 0; 2995 2996 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 2997 FileEntry *FEnt = static_cast<FileEntry *>(file); 2998 return CXXUnit->getPreprocessor().getHeaderSearchInfo() 2999 .isFileMultipleIncludeGuarded(FEnt); 3000} 3001 3002int clang_getFileUniqueID(CXFile file, CXFileUniqueID *outID) { 3003 if (!file || !outID) 3004 return 1; 3005 3006#ifdef LLVM_ON_WIN32 3007 return 1; // inodes not supported on windows. 3008#else 3009 FileEntry *FEnt = static_cast<FileEntry *>(file); 3010 outID->data[0] = FEnt->getDevice(); 3011 outID->data[1] = FEnt->getInode(); 3012 outID->data[2] = FEnt->getModificationTime(); 3013 return 0; 3014#endif 3015} 3016 3017} // end: extern "C" 3018 3019//===----------------------------------------------------------------------===// 3020// CXCursor Operations. 3021//===----------------------------------------------------------------------===// 3022 3023static const Decl *getDeclFromExpr(const Stmt *E) { 3024 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 3025 return getDeclFromExpr(CE->getSubExpr()); 3026 3027 if (const DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E)) 3028 return RefExpr->getDecl(); 3029 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) 3030 return ME->getMemberDecl(); 3031 if (const ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E)) 3032 return RE->getDecl(); 3033 if (const ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E)) { 3034 if (PRE->isExplicitProperty()) 3035 return PRE->getExplicitProperty(); 3036 // It could be messaging both getter and setter as in: 3037 // ++myobj.myprop; 3038 // in which case prefer to associate the setter since it is less obvious 3039 // from inspecting the source that the setter is going to get called. 3040 if (PRE->isMessagingSetter()) 3041 return PRE->getImplicitPropertySetter(); 3042 return PRE->getImplicitPropertyGetter(); 3043 } 3044 if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) 3045 return getDeclFromExpr(POE->getSyntacticForm()); 3046 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) 3047 if (Expr *Src = OVE->getSourceExpr()) 3048 return getDeclFromExpr(Src); 3049 3050 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) 3051 return getDeclFromExpr(CE->getCallee()); 3052 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E)) 3053 if (!CE->isElidable()) 3054 return CE->getConstructor(); 3055 if (const ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E)) 3056 return OME->getMethodDecl(); 3057 3058 if (const ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E)) 3059 return PE->getProtocol(); 3060 if (const SubstNonTypeTemplateParmPackExpr *NTTP 3061 = dyn_cast<SubstNonTypeTemplateParmPackExpr>(E)) 3062 return NTTP->getParameterPack(); 3063 if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 3064 if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) || 3065 isa<ParmVarDecl>(SizeOfPack->getPack())) 3066 return SizeOfPack->getPack(); 3067 3068 return 0; 3069} 3070 3071static SourceLocation getLocationFromExpr(const Expr *E) { 3072 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 3073 return getLocationFromExpr(CE->getSubExpr()); 3074 3075 if (const ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E)) 3076 return /*FIXME:*/Msg->getLeftLoc(); 3077 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 3078 return DRE->getLocation(); 3079 if (const MemberExpr *Member = dyn_cast<MemberExpr>(E)) 3080 return Member->getMemberLoc(); 3081 if (const ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E)) 3082 return Ivar->getLocation(); 3083 if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 3084 return SizeOfPack->getPackLoc(); 3085 if (const ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E)) 3086 return PropRef->getLocation(); 3087 3088 return E->getLocStart(); 3089} 3090 3091extern "C" { 3092 3093unsigned clang_visitChildren(CXCursor parent, 3094 CXCursorVisitor visitor, 3095 CXClientData client_data) { 3096 CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data, 3097 /*VisitPreprocessorLast=*/false); 3098 return CursorVis.VisitChildren(parent); 3099} 3100 3101#ifndef __has_feature 3102#define __has_feature(x) 0 3103#endif 3104#if __has_feature(blocks) 3105typedef enum CXChildVisitResult 3106 (^CXCursorVisitorBlock)(CXCursor cursor, CXCursor parent); 3107 3108static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 3109 CXClientData client_data) { 3110 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 3111 return block(cursor, parent); 3112} 3113#else 3114// If we are compiled with a compiler that doesn't have native blocks support, 3115// define and call the block manually, so the 3116typedef struct _CXChildVisitResult 3117{ 3118 void *isa; 3119 int flags; 3120 int reserved; 3121 enum CXChildVisitResult(*invoke)(struct _CXChildVisitResult*, CXCursor, 3122 CXCursor); 3123} *CXCursorVisitorBlock; 3124 3125static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 3126 CXClientData client_data) { 3127 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 3128 return block->invoke(block, cursor, parent); 3129} 3130#endif 3131 3132 3133unsigned clang_visitChildrenWithBlock(CXCursor parent, 3134 CXCursorVisitorBlock block) { 3135 return clang_visitChildren(parent, visitWithBlock, block); 3136} 3137 3138static CXString getDeclSpelling(const Decl *D) { 3139 if (!D) 3140 return cxstring::createEmpty(); 3141 3142 const NamedDecl *ND = dyn_cast<NamedDecl>(D); 3143 if (!ND) { 3144 if (const ObjCPropertyImplDecl *PropImpl = 3145 dyn_cast<ObjCPropertyImplDecl>(D)) 3146 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 3147 return cxstring::createDup(Property->getIdentifier()->getName()); 3148 3149 if (const ImportDecl *ImportD = dyn_cast<ImportDecl>(D)) 3150 if (Module *Mod = ImportD->getImportedModule()) 3151 return cxstring::createDup(Mod->getFullModuleName()); 3152 3153 return cxstring::createEmpty(); 3154 } 3155 3156 if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND)) 3157 return cxstring::createDup(OMD->getSelector().getAsString()); 3158 3159 if (const ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND)) 3160 // No, this isn't the same as the code below. getIdentifier() is non-virtual 3161 // and returns different names. NamedDecl returns the class name and 3162 // ObjCCategoryImplDecl returns the category name. 3163 return cxstring::createRef(CIMP->getIdentifier()->getNameStart()); 3164 3165 if (isa<UsingDirectiveDecl>(D)) 3166 return cxstring::createEmpty(); 3167 3168 SmallString<1024> S; 3169 llvm::raw_svector_ostream os(S); 3170 ND->printName(os); 3171 3172 return cxstring::createDup(os.str()); 3173} 3174 3175CXString clang_getCursorSpelling(CXCursor C) { 3176 if (clang_isTranslationUnit(C.kind)) 3177 return clang_getTranslationUnitSpelling(getCursorTU(C)); 3178 3179 if (clang_isReference(C.kind)) { 3180 switch (C.kind) { 3181 case CXCursor_ObjCSuperClassRef: { 3182 const ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first; 3183 return cxstring::createRef(Super->getIdentifier()->getNameStart()); 3184 } 3185 case CXCursor_ObjCClassRef: { 3186 const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first; 3187 return cxstring::createRef(Class->getIdentifier()->getNameStart()); 3188 } 3189 case CXCursor_ObjCProtocolRef: { 3190 const ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first; 3191 assert(OID && "getCursorSpelling(): Missing protocol decl"); 3192 return cxstring::createRef(OID->getIdentifier()->getNameStart()); 3193 } 3194 case CXCursor_CXXBaseSpecifier: { 3195 const CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C); 3196 return cxstring::createDup(B->getType().getAsString()); 3197 } 3198 case CXCursor_TypeRef: { 3199 const TypeDecl *Type = getCursorTypeRef(C).first; 3200 assert(Type && "Missing type decl"); 3201 3202 return cxstring::createDup(getCursorContext(C).getTypeDeclType(Type). 3203 getAsString()); 3204 } 3205 case CXCursor_TemplateRef: { 3206 const TemplateDecl *Template = getCursorTemplateRef(C).first; 3207 assert(Template && "Missing template decl"); 3208 3209 return cxstring::createDup(Template->getNameAsString()); 3210 } 3211 3212 case CXCursor_NamespaceRef: { 3213 const NamedDecl *NS = getCursorNamespaceRef(C).first; 3214 assert(NS && "Missing namespace decl"); 3215 3216 return cxstring::createDup(NS->getNameAsString()); 3217 } 3218 3219 case CXCursor_MemberRef: { 3220 const FieldDecl *Field = getCursorMemberRef(C).first; 3221 assert(Field && "Missing member decl"); 3222 3223 return cxstring::createDup(Field->getNameAsString()); 3224 } 3225 3226 case CXCursor_LabelRef: { 3227 const LabelStmt *Label = getCursorLabelRef(C).first; 3228 assert(Label && "Missing label"); 3229 3230 return cxstring::createRef(Label->getName()); 3231 } 3232 3233 case CXCursor_OverloadedDeclRef: { 3234 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 3235 if (const Decl *D = Storage.dyn_cast<const Decl *>()) { 3236 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) 3237 return cxstring::createDup(ND->getNameAsString()); 3238 return cxstring::createEmpty(); 3239 } 3240 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>()) 3241 return cxstring::createDup(E->getName().getAsString()); 3242 OverloadedTemplateStorage *Ovl 3243 = Storage.get<OverloadedTemplateStorage*>(); 3244 if (Ovl->size() == 0) 3245 return cxstring::createEmpty(); 3246 return cxstring::createDup((*Ovl->begin())->getNameAsString()); 3247 } 3248 3249 case CXCursor_VariableRef: { 3250 const VarDecl *Var = getCursorVariableRef(C).first; 3251 assert(Var && "Missing variable decl"); 3252 3253 return cxstring::createDup(Var->getNameAsString()); 3254 } 3255 3256 default: 3257 return cxstring::createRef("<not implemented>"); 3258 } 3259 } 3260 3261 if (clang_isExpression(C.kind)) { 3262 const Decl *D = getDeclFromExpr(getCursorExpr(C)); 3263 if (D) 3264 return getDeclSpelling(D); 3265 return cxstring::createEmpty(); 3266 } 3267 3268 if (clang_isStatement(C.kind)) { 3269 const Stmt *S = getCursorStmt(C); 3270 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) 3271 return cxstring::createRef(Label->getName()); 3272 3273 return cxstring::createEmpty(); 3274 } 3275 3276 if (C.kind == CXCursor_MacroExpansion) 3277 return cxstring::createRef(getCursorMacroExpansion(C).getName() 3278 ->getNameStart()); 3279 3280 if (C.kind == CXCursor_MacroDefinition) 3281 return cxstring::createRef(getCursorMacroDefinition(C)->getName() 3282 ->getNameStart()); 3283 3284 if (C.kind == CXCursor_InclusionDirective) 3285 return cxstring::createDup(getCursorInclusionDirective(C)->getFileName()); 3286 3287 if (clang_isDeclaration(C.kind)) 3288 return getDeclSpelling(getCursorDecl(C)); 3289 3290 if (C.kind == CXCursor_AnnotateAttr) { 3291 const AnnotateAttr *AA = cast<AnnotateAttr>(cxcursor::getCursorAttr(C)); 3292 return cxstring::createDup(AA->getAnnotation()); 3293 } 3294 3295 if (C.kind == CXCursor_AsmLabelAttr) { 3296 const AsmLabelAttr *AA = cast<AsmLabelAttr>(cxcursor::getCursorAttr(C)); 3297 return cxstring::createDup(AA->getLabel()); 3298 } 3299 3300 return cxstring::createEmpty(); 3301} 3302 3303CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C, 3304 unsigned pieceIndex, 3305 unsigned options) { 3306 if (clang_Cursor_isNull(C)) 3307 return clang_getNullRange(); 3308 3309 ASTContext &Ctx = getCursorContext(C); 3310 3311 if (clang_isStatement(C.kind)) { 3312 const Stmt *S = getCursorStmt(C); 3313 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) { 3314 if (pieceIndex > 0) 3315 return clang_getNullRange(); 3316 return cxloc::translateSourceRange(Ctx, Label->getIdentLoc()); 3317 } 3318 3319 return clang_getNullRange(); 3320 } 3321 3322 if (C.kind == CXCursor_ObjCMessageExpr) { 3323 if (const ObjCMessageExpr * 3324 ME = dyn_cast_or_null<ObjCMessageExpr>(getCursorExpr(C))) { 3325 if (pieceIndex >= ME->getNumSelectorLocs()) 3326 return clang_getNullRange(); 3327 return cxloc::translateSourceRange(Ctx, ME->getSelectorLoc(pieceIndex)); 3328 } 3329 } 3330 3331 if (C.kind == CXCursor_ObjCInstanceMethodDecl || 3332 C.kind == CXCursor_ObjCClassMethodDecl) { 3333 if (const ObjCMethodDecl * 3334 MD = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(C))) { 3335 if (pieceIndex >= MD->getNumSelectorLocs()) 3336 return clang_getNullRange(); 3337 return cxloc::translateSourceRange(Ctx, MD->getSelectorLoc(pieceIndex)); 3338 } 3339 } 3340 3341 if (C.kind == CXCursor_ObjCCategoryDecl || 3342 C.kind == CXCursor_ObjCCategoryImplDecl) { 3343 if (pieceIndex > 0) 3344 return clang_getNullRange(); 3345 if (const ObjCCategoryDecl * 3346 CD = dyn_cast_or_null<ObjCCategoryDecl>(getCursorDecl(C))) 3347 return cxloc::translateSourceRange(Ctx, CD->getCategoryNameLoc()); 3348 if (const ObjCCategoryImplDecl * 3349 CID = dyn_cast_or_null<ObjCCategoryImplDecl>(getCursorDecl(C))) 3350 return cxloc::translateSourceRange(Ctx, CID->getCategoryNameLoc()); 3351 } 3352 3353 if (C.kind == CXCursor_ModuleImportDecl) { 3354 if (pieceIndex > 0) 3355 return clang_getNullRange(); 3356 if (const ImportDecl *ImportD = 3357 dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) { 3358 ArrayRef<SourceLocation> Locs = ImportD->getIdentifierLocs(); 3359 if (!Locs.empty()) 3360 return cxloc::translateSourceRange(Ctx, 3361 SourceRange(Locs.front(), Locs.back())); 3362 } 3363 return clang_getNullRange(); 3364 } 3365 3366 // FIXME: A CXCursor_InclusionDirective should give the location of the 3367 // filename, but we don't keep track of this. 3368 3369 // FIXME: A CXCursor_AnnotateAttr should give the location of the annotation 3370 // but we don't keep track of this. 3371 3372 // FIXME: A CXCursor_AsmLabelAttr should give the location of the label 3373 // but we don't keep track of this. 3374 3375 // Default handling, give the location of the cursor. 3376 3377 if (pieceIndex > 0) 3378 return clang_getNullRange(); 3379 3380 CXSourceLocation CXLoc = clang_getCursorLocation(C); 3381 SourceLocation Loc = cxloc::translateSourceLocation(CXLoc); 3382 return cxloc::translateSourceRange(Ctx, Loc); 3383} 3384 3385CXString clang_getCursorDisplayName(CXCursor C) { 3386 if (!clang_isDeclaration(C.kind)) 3387 return clang_getCursorSpelling(C); 3388 3389 const Decl *D = getCursorDecl(C); 3390 if (!D) 3391 return cxstring::createEmpty(); 3392 3393 PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy(); 3394 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 3395 D = FunTmpl->getTemplatedDecl(); 3396 3397 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 3398 SmallString<64> Str; 3399 llvm::raw_svector_ostream OS(Str); 3400 OS << *Function; 3401 if (Function->getPrimaryTemplate()) 3402 OS << "<>"; 3403 OS << "("; 3404 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) { 3405 if (I) 3406 OS << ", "; 3407 OS << Function->getParamDecl(I)->getType().getAsString(Policy); 3408 } 3409 3410 if (Function->isVariadic()) { 3411 if (Function->getNumParams()) 3412 OS << ", "; 3413 OS << "..."; 3414 } 3415 OS << ")"; 3416 return cxstring::createDup(OS.str()); 3417 } 3418 3419 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) { 3420 SmallString<64> Str; 3421 llvm::raw_svector_ostream OS(Str); 3422 OS << *ClassTemplate; 3423 OS << "<"; 3424 TemplateParameterList *Params = ClassTemplate->getTemplateParameters(); 3425 for (unsigned I = 0, N = Params->size(); I != N; ++I) { 3426 if (I) 3427 OS << ", "; 3428 3429 NamedDecl *Param = Params->getParam(I); 3430 if (Param->getIdentifier()) { 3431 OS << Param->getIdentifier()->getName(); 3432 continue; 3433 } 3434 3435 // There is no parameter name, which makes this tricky. Try to come up 3436 // with something useful that isn't too long. 3437 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 3438 OS << (TTP->wasDeclaredWithTypename()? "typename" : "class"); 3439 else if (NonTypeTemplateParmDecl *NTTP 3440 = dyn_cast<NonTypeTemplateParmDecl>(Param)) 3441 OS << NTTP->getType().getAsString(Policy); 3442 else 3443 OS << "template<...> class"; 3444 } 3445 3446 OS << ">"; 3447 return cxstring::createDup(OS.str()); 3448 } 3449 3450 if (const ClassTemplateSpecializationDecl *ClassSpec 3451 = dyn_cast<ClassTemplateSpecializationDecl>(D)) { 3452 // If the type was explicitly written, use that. 3453 if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten()) 3454 return cxstring::createDup(TSInfo->getType().getAsString(Policy)); 3455 3456 SmallString<128> Str; 3457 llvm::raw_svector_ostream OS(Str); 3458 OS << *ClassSpec; 3459 TemplateSpecializationType::PrintTemplateArgumentList(OS, 3460 ClassSpec->getTemplateArgs().data(), 3461 ClassSpec->getTemplateArgs().size(), 3462 Policy); 3463 return cxstring::createDup(OS.str()); 3464 } 3465 3466 return clang_getCursorSpelling(C); 3467} 3468 3469CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) { 3470 switch (Kind) { 3471 case CXCursor_FunctionDecl: 3472 return cxstring::createRef("FunctionDecl"); 3473 case CXCursor_TypedefDecl: 3474 return cxstring::createRef("TypedefDecl"); 3475 case CXCursor_EnumDecl: 3476 return cxstring::createRef("EnumDecl"); 3477 case CXCursor_EnumConstantDecl: 3478 return cxstring::createRef("EnumConstantDecl"); 3479 case CXCursor_StructDecl: 3480 return cxstring::createRef("StructDecl"); 3481 case CXCursor_UnionDecl: 3482 return cxstring::createRef("UnionDecl"); 3483 case CXCursor_ClassDecl: 3484 return cxstring::createRef("ClassDecl"); 3485 case CXCursor_FieldDecl: 3486 return cxstring::createRef("FieldDecl"); 3487 case CXCursor_VarDecl: 3488 return cxstring::createRef("VarDecl"); 3489 case CXCursor_ParmDecl: 3490 return cxstring::createRef("ParmDecl"); 3491 case CXCursor_ObjCInterfaceDecl: 3492 return cxstring::createRef("ObjCInterfaceDecl"); 3493 case CXCursor_ObjCCategoryDecl: 3494 return cxstring::createRef("ObjCCategoryDecl"); 3495 case CXCursor_ObjCProtocolDecl: 3496 return cxstring::createRef("ObjCProtocolDecl"); 3497 case CXCursor_ObjCPropertyDecl: 3498 return cxstring::createRef("ObjCPropertyDecl"); 3499 case CXCursor_ObjCIvarDecl: 3500 return cxstring::createRef("ObjCIvarDecl"); 3501 case CXCursor_ObjCInstanceMethodDecl: 3502 return cxstring::createRef("ObjCInstanceMethodDecl"); 3503 case CXCursor_ObjCClassMethodDecl: 3504 return cxstring::createRef("ObjCClassMethodDecl"); 3505 case CXCursor_ObjCImplementationDecl: 3506 return cxstring::createRef("ObjCImplementationDecl"); 3507 case CXCursor_ObjCCategoryImplDecl: 3508 return cxstring::createRef("ObjCCategoryImplDecl"); 3509 case CXCursor_CXXMethod: 3510 return cxstring::createRef("CXXMethod"); 3511 case CXCursor_UnexposedDecl: 3512 return cxstring::createRef("UnexposedDecl"); 3513 case CXCursor_ObjCSuperClassRef: 3514 return cxstring::createRef("ObjCSuperClassRef"); 3515 case CXCursor_ObjCProtocolRef: 3516 return cxstring::createRef("ObjCProtocolRef"); 3517 case CXCursor_ObjCClassRef: 3518 return cxstring::createRef("ObjCClassRef"); 3519 case CXCursor_TypeRef: 3520 return cxstring::createRef("TypeRef"); 3521 case CXCursor_TemplateRef: 3522 return cxstring::createRef("TemplateRef"); 3523 case CXCursor_NamespaceRef: 3524 return cxstring::createRef("NamespaceRef"); 3525 case CXCursor_MemberRef: 3526 return cxstring::createRef("MemberRef"); 3527 case CXCursor_LabelRef: 3528 return cxstring::createRef("LabelRef"); 3529 case CXCursor_OverloadedDeclRef: 3530 return cxstring::createRef("OverloadedDeclRef"); 3531 case CXCursor_VariableRef: 3532 return cxstring::createRef("VariableRef"); 3533 case CXCursor_IntegerLiteral: 3534 return cxstring::createRef("IntegerLiteral"); 3535 case CXCursor_FloatingLiteral: 3536 return cxstring::createRef("FloatingLiteral"); 3537 case CXCursor_ImaginaryLiteral: 3538 return cxstring::createRef("ImaginaryLiteral"); 3539 case CXCursor_StringLiteral: 3540 return cxstring::createRef("StringLiteral"); 3541 case CXCursor_CharacterLiteral: 3542 return cxstring::createRef("CharacterLiteral"); 3543 case CXCursor_ParenExpr: 3544 return cxstring::createRef("ParenExpr"); 3545 case CXCursor_UnaryOperator: 3546 return cxstring::createRef("UnaryOperator"); 3547 case CXCursor_ArraySubscriptExpr: 3548 return cxstring::createRef("ArraySubscriptExpr"); 3549 case CXCursor_BinaryOperator: 3550 return cxstring::createRef("BinaryOperator"); 3551 case CXCursor_CompoundAssignOperator: 3552 return cxstring::createRef("CompoundAssignOperator"); 3553 case CXCursor_ConditionalOperator: 3554 return cxstring::createRef("ConditionalOperator"); 3555 case CXCursor_CStyleCastExpr: 3556 return cxstring::createRef("CStyleCastExpr"); 3557 case CXCursor_CompoundLiteralExpr: 3558 return cxstring::createRef("CompoundLiteralExpr"); 3559 case CXCursor_InitListExpr: 3560 return cxstring::createRef("InitListExpr"); 3561 case CXCursor_AddrLabelExpr: 3562 return cxstring::createRef("AddrLabelExpr"); 3563 case CXCursor_StmtExpr: 3564 return cxstring::createRef("StmtExpr"); 3565 case CXCursor_GenericSelectionExpr: 3566 return cxstring::createRef("GenericSelectionExpr"); 3567 case CXCursor_GNUNullExpr: 3568 return cxstring::createRef("GNUNullExpr"); 3569 case CXCursor_CXXStaticCastExpr: 3570 return cxstring::createRef("CXXStaticCastExpr"); 3571 case CXCursor_CXXDynamicCastExpr: 3572 return cxstring::createRef("CXXDynamicCastExpr"); 3573 case CXCursor_CXXReinterpretCastExpr: 3574 return cxstring::createRef("CXXReinterpretCastExpr"); 3575 case CXCursor_CXXConstCastExpr: 3576 return cxstring::createRef("CXXConstCastExpr"); 3577 case CXCursor_CXXFunctionalCastExpr: 3578 return cxstring::createRef("CXXFunctionalCastExpr"); 3579 case CXCursor_CXXTypeidExpr: 3580 return cxstring::createRef("CXXTypeidExpr"); 3581 case CXCursor_CXXBoolLiteralExpr: 3582 return cxstring::createRef("CXXBoolLiteralExpr"); 3583 case CXCursor_CXXNullPtrLiteralExpr: 3584 return cxstring::createRef("CXXNullPtrLiteralExpr"); 3585 case CXCursor_CXXThisExpr: 3586 return cxstring::createRef("CXXThisExpr"); 3587 case CXCursor_CXXThrowExpr: 3588 return cxstring::createRef("CXXThrowExpr"); 3589 case CXCursor_CXXNewExpr: 3590 return cxstring::createRef("CXXNewExpr"); 3591 case CXCursor_CXXDeleteExpr: 3592 return cxstring::createRef("CXXDeleteExpr"); 3593 case CXCursor_UnaryExpr: 3594 return cxstring::createRef("UnaryExpr"); 3595 case CXCursor_ObjCStringLiteral: 3596 return cxstring::createRef("ObjCStringLiteral"); 3597 case CXCursor_ObjCBoolLiteralExpr: 3598 return cxstring::createRef("ObjCBoolLiteralExpr"); 3599 case CXCursor_ObjCSelfExpr: 3600 return cxstring::createRef("ObjCSelfExpr"); 3601 case CXCursor_ObjCEncodeExpr: 3602 return cxstring::createRef("ObjCEncodeExpr"); 3603 case CXCursor_ObjCSelectorExpr: 3604 return cxstring::createRef("ObjCSelectorExpr"); 3605 case CXCursor_ObjCProtocolExpr: 3606 return cxstring::createRef("ObjCProtocolExpr"); 3607 case CXCursor_ObjCBridgedCastExpr: 3608 return cxstring::createRef("ObjCBridgedCastExpr"); 3609 case CXCursor_BlockExpr: 3610 return cxstring::createRef("BlockExpr"); 3611 case CXCursor_PackExpansionExpr: 3612 return cxstring::createRef("PackExpansionExpr"); 3613 case CXCursor_SizeOfPackExpr: 3614 return cxstring::createRef("SizeOfPackExpr"); 3615 case CXCursor_LambdaExpr: 3616 return cxstring::createRef("LambdaExpr"); 3617 case CXCursor_UnexposedExpr: 3618 return cxstring::createRef("UnexposedExpr"); 3619 case CXCursor_DeclRefExpr: 3620 return cxstring::createRef("DeclRefExpr"); 3621 case CXCursor_MemberRefExpr: 3622 return cxstring::createRef("MemberRefExpr"); 3623 case CXCursor_CallExpr: 3624 return cxstring::createRef("CallExpr"); 3625 case CXCursor_ObjCMessageExpr: 3626 return cxstring::createRef("ObjCMessageExpr"); 3627 case CXCursor_UnexposedStmt: 3628 return cxstring::createRef("UnexposedStmt"); 3629 case CXCursor_DeclStmt: 3630 return cxstring::createRef("DeclStmt"); 3631 case CXCursor_LabelStmt: 3632 return cxstring::createRef("LabelStmt"); 3633 case CXCursor_CompoundStmt: 3634 return cxstring::createRef("CompoundStmt"); 3635 case CXCursor_CaseStmt: 3636 return cxstring::createRef("CaseStmt"); 3637 case CXCursor_DefaultStmt: 3638 return cxstring::createRef("DefaultStmt"); 3639 case CXCursor_IfStmt: 3640 return cxstring::createRef("IfStmt"); 3641 case CXCursor_SwitchStmt: 3642 return cxstring::createRef("SwitchStmt"); 3643 case CXCursor_WhileStmt: 3644 return cxstring::createRef("WhileStmt"); 3645 case CXCursor_DoStmt: 3646 return cxstring::createRef("DoStmt"); 3647 case CXCursor_ForStmt: 3648 return cxstring::createRef("ForStmt"); 3649 case CXCursor_GotoStmt: 3650 return cxstring::createRef("GotoStmt"); 3651 case CXCursor_IndirectGotoStmt: 3652 return cxstring::createRef("IndirectGotoStmt"); 3653 case CXCursor_ContinueStmt: 3654 return cxstring::createRef("ContinueStmt"); 3655 case CXCursor_BreakStmt: 3656 return cxstring::createRef("BreakStmt"); 3657 case CXCursor_ReturnStmt: 3658 return cxstring::createRef("ReturnStmt"); 3659 case CXCursor_GCCAsmStmt: 3660 return cxstring::createRef("GCCAsmStmt"); 3661 case CXCursor_MSAsmStmt: 3662 return cxstring::createRef("MSAsmStmt"); 3663 case CXCursor_ObjCAtTryStmt: 3664 return cxstring::createRef("ObjCAtTryStmt"); 3665 case CXCursor_ObjCAtCatchStmt: 3666 return cxstring::createRef("ObjCAtCatchStmt"); 3667 case CXCursor_ObjCAtFinallyStmt: 3668 return cxstring::createRef("ObjCAtFinallyStmt"); 3669 case CXCursor_ObjCAtThrowStmt: 3670 return cxstring::createRef("ObjCAtThrowStmt"); 3671 case CXCursor_ObjCAtSynchronizedStmt: 3672 return cxstring::createRef("ObjCAtSynchronizedStmt"); 3673 case CXCursor_ObjCAutoreleasePoolStmt: 3674 return cxstring::createRef("ObjCAutoreleasePoolStmt"); 3675 case CXCursor_ObjCForCollectionStmt: 3676 return cxstring::createRef("ObjCForCollectionStmt"); 3677 case CXCursor_CXXCatchStmt: 3678 return cxstring::createRef("CXXCatchStmt"); 3679 case CXCursor_CXXTryStmt: 3680 return cxstring::createRef("CXXTryStmt"); 3681 case CXCursor_CXXForRangeStmt: 3682 return cxstring::createRef("CXXForRangeStmt"); 3683 case CXCursor_SEHTryStmt: 3684 return cxstring::createRef("SEHTryStmt"); 3685 case CXCursor_SEHExceptStmt: 3686 return cxstring::createRef("SEHExceptStmt"); 3687 case CXCursor_SEHFinallyStmt: 3688 return cxstring::createRef("SEHFinallyStmt"); 3689 case CXCursor_NullStmt: 3690 return cxstring::createRef("NullStmt"); 3691 case CXCursor_InvalidFile: 3692 return cxstring::createRef("InvalidFile"); 3693 case CXCursor_InvalidCode: 3694 return cxstring::createRef("InvalidCode"); 3695 case CXCursor_NoDeclFound: 3696 return cxstring::createRef("NoDeclFound"); 3697 case CXCursor_NotImplemented: 3698 return cxstring::createRef("NotImplemented"); 3699 case CXCursor_TranslationUnit: 3700 return cxstring::createRef("TranslationUnit"); 3701 case CXCursor_UnexposedAttr: 3702 return cxstring::createRef("UnexposedAttr"); 3703 case CXCursor_IBActionAttr: 3704 return cxstring::createRef("attribute(ibaction)"); 3705 case CXCursor_IBOutletAttr: 3706 return cxstring::createRef("attribute(iboutlet)"); 3707 case CXCursor_IBOutletCollectionAttr: 3708 return cxstring::createRef("attribute(iboutletcollection)"); 3709 case CXCursor_CXXFinalAttr: 3710 return cxstring::createRef("attribute(final)"); 3711 case CXCursor_CXXOverrideAttr: 3712 return cxstring::createRef("attribute(override)"); 3713 case CXCursor_AnnotateAttr: 3714 return cxstring::createRef("attribute(annotate)"); 3715 case CXCursor_AsmLabelAttr: 3716 return cxstring::createRef("asm label"); 3717 case CXCursor_PreprocessingDirective: 3718 return cxstring::createRef("preprocessing directive"); 3719 case CXCursor_MacroDefinition: 3720 return cxstring::createRef("macro definition"); 3721 case CXCursor_MacroExpansion: 3722 return cxstring::createRef("macro expansion"); 3723 case CXCursor_InclusionDirective: 3724 return cxstring::createRef("inclusion directive"); 3725 case CXCursor_Namespace: 3726 return cxstring::createRef("Namespace"); 3727 case CXCursor_LinkageSpec: 3728 return cxstring::createRef("LinkageSpec"); 3729 case CXCursor_CXXBaseSpecifier: 3730 return cxstring::createRef("C++ base class specifier"); 3731 case CXCursor_Constructor: 3732 return cxstring::createRef("CXXConstructor"); 3733 case CXCursor_Destructor: 3734 return cxstring::createRef("CXXDestructor"); 3735 case CXCursor_ConversionFunction: 3736 return cxstring::createRef("CXXConversion"); 3737 case CXCursor_TemplateTypeParameter: 3738 return cxstring::createRef("TemplateTypeParameter"); 3739 case CXCursor_NonTypeTemplateParameter: 3740 return cxstring::createRef("NonTypeTemplateParameter"); 3741 case CXCursor_TemplateTemplateParameter: 3742 return cxstring::createRef("TemplateTemplateParameter"); 3743 case CXCursor_FunctionTemplate: 3744 return cxstring::createRef("FunctionTemplate"); 3745 case CXCursor_ClassTemplate: 3746 return cxstring::createRef("ClassTemplate"); 3747 case CXCursor_ClassTemplatePartialSpecialization: 3748 return cxstring::createRef("ClassTemplatePartialSpecialization"); 3749 case CXCursor_NamespaceAlias: 3750 return cxstring::createRef("NamespaceAlias"); 3751 case CXCursor_UsingDirective: 3752 return cxstring::createRef("UsingDirective"); 3753 case CXCursor_UsingDeclaration: 3754 return cxstring::createRef("UsingDeclaration"); 3755 case CXCursor_TypeAliasDecl: 3756 return cxstring::createRef("TypeAliasDecl"); 3757 case CXCursor_ObjCSynthesizeDecl: 3758 return cxstring::createRef("ObjCSynthesizeDecl"); 3759 case CXCursor_ObjCDynamicDecl: 3760 return cxstring::createRef("ObjCDynamicDecl"); 3761 case CXCursor_CXXAccessSpecifier: 3762 return cxstring::createRef("CXXAccessSpecifier"); 3763 case CXCursor_ModuleImportDecl: 3764 return cxstring::createRef("ModuleImport"); 3765 } 3766 3767 llvm_unreachable("Unhandled CXCursorKind"); 3768} 3769 3770struct GetCursorData { 3771 SourceLocation TokenBeginLoc; 3772 bool PointsAtMacroArgExpansion; 3773 bool VisitedObjCPropertyImplDecl; 3774 SourceLocation VisitedDeclaratorDeclStartLoc; 3775 CXCursor &BestCursor; 3776 3777 GetCursorData(SourceManager &SM, 3778 SourceLocation tokenBegin, CXCursor &outputCursor) 3779 : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) { 3780 PointsAtMacroArgExpansion = SM.isMacroArgExpansion(tokenBegin); 3781 VisitedObjCPropertyImplDecl = false; 3782 } 3783}; 3784 3785static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor, 3786 CXCursor parent, 3787 CXClientData client_data) { 3788 GetCursorData *Data = static_cast<GetCursorData *>(client_data); 3789 CXCursor *BestCursor = &Data->BestCursor; 3790 3791 // If we point inside a macro argument we should provide info of what the 3792 // token is so use the actual cursor, don't replace it with a macro expansion 3793 // cursor. 3794 if (cursor.kind == CXCursor_MacroExpansion && Data->PointsAtMacroArgExpansion) 3795 return CXChildVisit_Recurse; 3796 3797 if (clang_isDeclaration(cursor.kind)) { 3798 // Avoid having the implicit methods override the property decls. 3799 if (const ObjCMethodDecl *MD 3800 = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) { 3801 if (MD->isImplicit()) 3802 return CXChildVisit_Break; 3803 3804 } else if (const ObjCInterfaceDecl *ID 3805 = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(cursor))) { 3806 // Check that when we have multiple @class references in the same line, 3807 // that later ones do not override the previous ones. 3808 // If we have: 3809 // @class Foo, Bar; 3810 // source ranges for both start at '@', so 'Bar' will end up overriding 3811 // 'Foo' even though the cursor location was at 'Foo'. 3812 if (BestCursor->kind == CXCursor_ObjCInterfaceDecl || 3813 BestCursor->kind == CXCursor_ObjCClassRef) 3814 if (const ObjCInterfaceDecl *PrevID 3815 = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(*BestCursor))){ 3816 if (PrevID != ID && 3817 !PrevID->isThisDeclarationADefinition() && 3818 !ID->isThisDeclarationADefinition()) 3819 return CXChildVisit_Break; 3820 } 3821 3822 } else if (const DeclaratorDecl *DD 3823 = dyn_cast_or_null<DeclaratorDecl>(getCursorDecl(cursor))) { 3824 SourceLocation StartLoc = DD->getSourceRange().getBegin(); 3825 // Check that when we have multiple declarators in the same line, 3826 // that later ones do not override the previous ones. 3827 // If we have: 3828 // int Foo, Bar; 3829 // source ranges for both start at 'int', so 'Bar' will end up overriding 3830 // 'Foo' even though the cursor location was at 'Foo'. 3831 if (Data->VisitedDeclaratorDeclStartLoc == StartLoc) 3832 return CXChildVisit_Break; 3833 Data->VisitedDeclaratorDeclStartLoc = StartLoc; 3834 3835 } else if (const ObjCPropertyImplDecl *PropImp 3836 = dyn_cast_or_null<ObjCPropertyImplDecl>(getCursorDecl(cursor))) { 3837 (void)PropImp; 3838 // Check that when we have multiple @synthesize in the same line, 3839 // that later ones do not override the previous ones. 3840 // If we have: 3841 // @synthesize Foo, Bar; 3842 // source ranges for both start at '@', so 'Bar' will end up overriding 3843 // 'Foo' even though the cursor location was at 'Foo'. 3844 if (Data->VisitedObjCPropertyImplDecl) 3845 return CXChildVisit_Break; 3846 Data->VisitedObjCPropertyImplDecl = true; 3847 } 3848 } 3849 3850 if (clang_isExpression(cursor.kind) && 3851 clang_isDeclaration(BestCursor->kind)) { 3852 if (const Decl *D = getCursorDecl(*BestCursor)) { 3853 // Avoid having the cursor of an expression replace the declaration cursor 3854 // when the expression source range overlaps the declaration range. 3855 // This can happen for C++ constructor expressions whose range generally 3856 // include the variable declaration, e.g.: 3857 // MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl cursor. 3858 if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() && 3859 D->getLocation() == Data->TokenBeginLoc) 3860 return CXChildVisit_Break; 3861 } 3862 } 3863 3864 // If our current best cursor is the construction of a temporary object, 3865 // don't replace that cursor with a type reference, because we want 3866 // clang_getCursor() to point at the constructor. 3867 if (clang_isExpression(BestCursor->kind) && 3868 isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) && 3869 cursor.kind == CXCursor_TypeRef) { 3870 // Keep the cursor pointing at CXXTemporaryObjectExpr but also mark it 3871 // as having the actual point on the type reference. 3872 *BestCursor = getTypeRefedCallExprCursor(*BestCursor); 3873 return CXChildVisit_Recurse; 3874 } 3875 3876 *BestCursor = cursor; 3877 return CXChildVisit_Recurse; 3878} 3879 3880CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) { 3881 if (!TU) 3882 return clang_getNullCursor(); 3883 3884 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 3885 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 3886 3887 SourceLocation SLoc = cxloc::translateSourceLocation(Loc); 3888 CXCursor Result = cxcursor::getCursor(TU, SLoc); 3889 3890 LOG_FUNC_SECTION { 3891 CXFile SearchFile; 3892 unsigned SearchLine, SearchColumn; 3893 CXFile ResultFile; 3894 unsigned ResultLine, ResultColumn; 3895 CXString SearchFileName, ResultFileName, KindSpelling, USR; 3896 const char *IsDef = clang_isCursorDefinition(Result)? " (Definition)" : ""; 3897 CXSourceLocation ResultLoc = clang_getCursorLocation(Result); 3898 3899 clang_getFileLocation(Loc, &SearchFile, &SearchLine, &SearchColumn, 0); 3900 clang_getFileLocation(ResultLoc, &ResultFile, &ResultLine, 3901 &ResultColumn, 0); 3902 SearchFileName = clang_getFileName(SearchFile); 3903 ResultFileName = clang_getFileName(ResultFile); 3904 KindSpelling = clang_getCursorKindSpelling(Result.kind); 3905 USR = clang_getCursorUSR(Result); 3906 *Log << llvm::format("(%s:%d:%d) = %s", 3907 clang_getCString(SearchFileName), SearchLine, SearchColumn, 3908 clang_getCString(KindSpelling)) 3909 << llvm::format("(%s:%d:%d):%s%s", 3910 clang_getCString(ResultFileName), ResultLine, ResultColumn, 3911 clang_getCString(USR), IsDef); 3912 clang_disposeString(SearchFileName); 3913 clang_disposeString(ResultFileName); 3914 clang_disposeString(KindSpelling); 3915 clang_disposeString(USR); 3916 3917 CXCursor Definition = clang_getCursorDefinition(Result); 3918 if (!clang_equalCursors(Definition, clang_getNullCursor())) { 3919 CXSourceLocation DefinitionLoc = clang_getCursorLocation(Definition); 3920 CXString DefinitionKindSpelling 3921 = clang_getCursorKindSpelling(Definition.kind); 3922 CXFile DefinitionFile; 3923 unsigned DefinitionLine, DefinitionColumn; 3924 clang_getFileLocation(DefinitionLoc, &DefinitionFile, 3925 &DefinitionLine, &DefinitionColumn, 0); 3926 CXString DefinitionFileName = clang_getFileName(DefinitionFile); 3927 *Log << llvm::format(" -> %s(%s:%d:%d)", 3928 clang_getCString(DefinitionKindSpelling), 3929 clang_getCString(DefinitionFileName), 3930 DefinitionLine, DefinitionColumn); 3931 clang_disposeString(DefinitionFileName); 3932 clang_disposeString(DefinitionKindSpelling); 3933 } 3934 } 3935 3936 return Result; 3937} 3938 3939CXCursor clang_getNullCursor(void) { 3940 return MakeCXCursorInvalid(CXCursor_InvalidFile); 3941} 3942 3943unsigned clang_equalCursors(CXCursor X, CXCursor Y) { 3944 // Clear out the "FirstInDeclGroup" part in a declaration cursor, since we 3945 // can't set consistently. For example, when visiting a DeclStmt we will set 3946 // it but we don't set it on the result of clang_getCursorDefinition for 3947 // a reference of the same declaration. 3948 // FIXME: Setting "FirstInDeclGroup" in CXCursors is a hack that only works 3949 // when visiting a DeclStmt currently, the AST should be enhanced to be able 3950 // to provide that kind of info. 3951 if (clang_isDeclaration(X.kind)) 3952 X.data[1] = 0; 3953 if (clang_isDeclaration(Y.kind)) 3954 Y.data[1] = 0; 3955 3956 return X == Y; 3957} 3958 3959unsigned clang_hashCursor(CXCursor C) { 3960 unsigned Index = 0; 3961 if (clang_isExpression(C.kind) || clang_isStatement(C.kind)) 3962 Index = 1; 3963 3964 return llvm::DenseMapInfo<std::pair<unsigned, const void*> >::getHashValue( 3965 std::make_pair(C.kind, C.data[Index])); 3966} 3967 3968unsigned clang_isInvalid(enum CXCursorKind K) { 3969 return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid; 3970} 3971 3972unsigned clang_isDeclaration(enum CXCursorKind K) { 3973 return (K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl) || 3974 (K >= CXCursor_FirstExtraDecl && K <= CXCursor_LastExtraDecl); 3975} 3976 3977unsigned clang_isReference(enum CXCursorKind K) { 3978 return K >= CXCursor_FirstRef && K <= CXCursor_LastRef; 3979} 3980 3981unsigned clang_isExpression(enum CXCursorKind K) { 3982 return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr; 3983} 3984 3985unsigned clang_isStatement(enum CXCursorKind K) { 3986 return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt; 3987} 3988 3989unsigned clang_isAttribute(enum CXCursorKind K) { 3990 return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr; 3991} 3992 3993unsigned clang_isTranslationUnit(enum CXCursorKind K) { 3994 return K == CXCursor_TranslationUnit; 3995} 3996 3997unsigned clang_isPreprocessing(enum CXCursorKind K) { 3998 return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing; 3999} 4000 4001unsigned clang_isUnexposed(enum CXCursorKind K) { 4002 switch (K) { 4003 case CXCursor_UnexposedDecl: 4004 case CXCursor_UnexposedExpr: 4005 case CXCursor_UnexposedStmt: 4006 case CXCursor_UnexposedAttr: 4007 return true; 4008 default: 4009 return false; 4010 } 4011} 4012 4013CXCursorKind clang_getCursorKind(CXCursor C) { 4014 return C.kind; 4015} 4016 4017CXSourceLocation clang_getCursorLocation(CXCursor C) { 4018 if (clang_isReference(C.kind)) { 4019 switch (C.kind) { 4020 case CXCursor_ObjCSuperClassRef: { 4021 std::pair<const ObjCInterfaceDecl *, SourceLocation> P 4022 = getCursorObjCSuperClassRef(C); 4023 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4024 } 4025 4026 case CXCursor_ObjCProtocolRef: { 4027 std::pair<const ObjCProtocolDecl *, SourceLocation> P 4028 = getCursorObjCProtocolRef(C); 4029 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4030 } 4031 4032 case CXCursor_ObjCClassRef: { 4033 std::pair<const ObjCInterfaceDecl *, SourceLocation> P 4034 = getCursorObjCClassRef(C); 4035 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4036 } 4037 4038 case CXCursor_TypeRef: { 4039 std::pair<const TypeDecl *, SourceLocation> P = getCursorTypeRef(C); 4040 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4041 } 4042 4043 case CXCursor_TemplateRef: { 4044 std::pair<const TemplateDecl *, SourceLocation> P = 4045 getCursorTemplateRef(C); 4046 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4047 } 4048 4049 case CXCursor_NamespaceRef: { 4050 std::pair<const NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C); 4051 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4052 } 4053 4054 case CXCursor_MemberRef: { 4055 std::pair<const FieldDecl *, SourceLocation> P = getCursorMemberRef(C); 4056 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4057 } 4058 4059 case CXCursor_VariableRef: { 4060 std::pair<const VarDecl *, SourceLocation> P = getCursorVariableRef(C); 4061 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4062 } 4063 4064 case CXCursor_CXXBaseSpecifier: { 4065 const CXXBaseSpecifier *BaseSpec = getCursorCXXBaseSpecifier(C); 4066 if (!BaseSpec) 4067 return clang_getNullLocation(); 4068 4069 if (TypeSourceInfo *TSInfo = BaseSpec->getTypeSourceInfo()) 4070 return cxloc::translateSourceLocation(getCursorContext(C), 4071 TSInfo->getTypeLoc().getBeginLoc()); 4072 4073 return cxloc::translateSourceLocation(getCursorContext(C), 4074 BaseSpec->getLocStart()); 4075 } 4076 4077 case CXCursor_LabelRef: { 4078 std::pair<const LabelStmt *, SourceLocation> P = getCursorLabelRef(C); 4079 return cxloc::translateSourceLocation(getCursorContext(C), P.second); 4080 } 4081 4082 case CXCursor_OverloadedDeclRef: 4083 return cxloc::translateSourceLocation(getCursorContext(C), 4084 getCursorOverloadedDeclRef(C).second); 4085 4086 default: 4087 // FIXME: Need a way to enumerate all non-reference cases. 4088 llvm_unreachable("Missed a reference kind"); 4089 } 4090 } 4091 4092 if (clang_isExpression(C.kind)) 4093 return cxloc::translateSourceLocation(getCursorContext(C), 4094 getLocationFromExpr(getCursorExpr(C))); 4095 4096 if (clang_isStatement(C.kind)) 4097 return cxloc::translateSourceLocation(getCursorContext(C), 4098 getCursorStmt(C)->getLocStart()); 4099 4100 if (C.kind == CXCursor_PreprocessingDirective) { 4101 SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin(); 4102 return cxloc::translateSourceLocation(getCursorContext(C), L); 4103 } 4104 4105 if (C.kind == CXCursor_MacroExpansion) { 4106 SourceLocation L 4107 = cxcursor::getCursorMacroExpansion(C).getSourceRange().getBegin(); 4108 return cxloc::translateSourceLocation(getCursorContext(C), L); 4109 } 4110 4111 if (C.kind == CXCursor_MacroDefinition) { 4112 SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation(); 4113 return cxloc::translateSourceLocation(getCursorContext(C), L); 4114 } 4115 4116 if (C.kind == CXCursor_InclusionDirective) { 4117 SourceLocation L 4118 = cxcursor::getCursorInclusionDirective(C)->getSourceRange().getBegin(); 4119 return cxloc::translateSourceLocation(getCursorContext(C), L); 4120 } 4121 4122 if (!clang_isDeclaration(C.kind)) 4123 return clang_getNullLocation(); 4124 4125 const Decl *D = getCursorDecl(C); 4126 if (!D) 4127 return clang_getNullLocation(); 4128 4129 SourceLocation Loc = D->getLocation(); 4130 // FIXME: Multiple variables declared in a single declaration 4131 // currently lack the information needed to correctly determine their 4132 // ranges when accounting for the type-specifier. We use context 4133 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 4134 // and if so, whether it is the first decl. 4135 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 4136 if (!cxcursor::isFirstInDeclGroup(C)) 4137 Loc = VD->getLocation(); 4138 } 4139 4140 // For ObjC methods, give the start location of the method name. 4141 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 4142 Loc = MD->getSelectorStartLoc(); 4143 4144 return cxloc::translateSourceLocation(getCursorContext(C), Loc); 4145} 4146 4147} // end extern "C" 4148 4149CXCursor cxcursor::getCursor(CXTranslationUnit TU, SourceLocation SLoc) { 4150 assert(TU); 4151 4152 // Guard against an invalid SourceLocation, or we may assert in one 4153 // of the following calls. 4154 if (SLoc.isInvalid()) 4155 return clang_getNullCursor(); 4156 4157 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4158 4159 // Translate the given source location to make it point at the beginning of 4160 // the token under the cursor. 4161 SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(), 4162 CXXUnit->getASTContext().getLangOpts()); 4163 4164 CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound); 4165 if (SLoc.isValid()) { 4166 GetCursorData ResultData(CXXUnit->getSourceManager(), SLoc, Result); 4167 CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData, 4168 /*VisitPreprocessorLast=*/true, 4169 /*VisitIncludedEntities=*/false, 4170 SourceLocation(SLoc)); 4171 CursorVis.visitFileRegion(); 4172 } 4173 4174 return Result; 4175} 4176 4177static SourceRange getRawCursorExtent(CXCursor C) { 4178 if (clang_isReference(C.kind)) { 4179 switch (C.kind) { 4180 case CXCursor_ObjCSuperClassRef: 4181 return getCursorObjCSuperClassRef(C).second; 4182 4183 case CXCursor_ObjCProtocolRef: 4184 return getCursorObjCProtocolRef(C).second; 4185 4186 case CXCursor_ObjCClassRef: 4187 return getCursorObjCClassRef(C).second; 4188 4189 case CXCursor_TypeRef: 4190 return getCursorTypeRef(C).second; 4191 4192 case CXCursor_TemplateRef: 4193 return getCursorTemplateRef(C).second; 4194 4195 case CXCursor_NamespaceRef: 4196 return getCursorNamespaceRef(C).second; 4197 4198 case CXCursor_MemberRef: 4199 return getCursorMemberRef(C).second; 4200 4201 case CXCursor_CXXBaseSpecifier: 4202 return getCursorCXXBaseSpecifier(C)->getSourceRange(); 4203 4204 case CXCursor_LabelRef: 4205 return getCursorLabelRef(C).second; 4206 4207 case CXCursor_OverloadedDeclRef: 4208 return getCursorOverloadedDeclRef(C).second; 4209 4210 case CXCursor_VariableRef: 4211 return getCursorVariableRef(C).second; 4212 4213 default: 4214 // FIXME: Need a way to enumerate all non-reference cases. 4215 llvm_unreachable("Missed a reference kind"); 4216 } 4217 } 4218 4219 if (clang_isExpression(C.kind)) 4220 return getCursorExpr(C)->getSourceRange(); 4221 4222 if (clang_isStatement(C.kind)) 4223 return getCursorStmt(C)->getSourceRange(); 4224 4225 if (clang_isAttribute(C.kind)) 4226 return getCursorAttr(C)->getRange(); 4227 4228 if (C.kind == CXCursor_PreprocessingDirective) 4229 return cxcursor::getCursorPreprocessingDirective(C); 4230 4231 if (C.kind == CXCursor_MacroExpansion) { 4232 ASTUnit *TU = getCursorASTUnit(C); 4233 SourceRange Range = cxcursor::getCursorMacroExpansion(C).getSourceRange(); 4234 return TU->mapRangeFromPreamble(Range); 4235 } 4236 4237 if (C.kind == CXCursor_MacroDefinition) { 4238 ASTUnit *TU = getCursorASTUnit(C); 4239 SourceRange Range = cxcursor::getCursorMacroDefinition(C)->getSourceRange(); 4240 return TU->mapRangeFromPreamble(Range); 4241 } 4242 4243 if (C.kind == CXCursor_InclusionDirective) { 4244 ASTUnit *TU = getCursorASTUnit(C); 4245 SourceRange Range = cxcursor::getCursorInclusionDirective(C)->getSourceRange(); 4246 return TU->mapRangeFromPreamble(Range); 4247 } 4248 4249 if (C.kind == CXCursor_TranslationUnit) { 4250 ASTUnit *TU = getCursorASTUnit(C); 4251 FileID MainID = TU->getSourceManager().getMainFileID(); 4252 SourceLocation Start = TU->getSourceManager().getLocForStartOfFile(MainID); 4253 SourceLocation End = TU->getSourceManager().getLocForEndOfFile(MainID); 4254 return SourceRange(Start, End); 4255 } 4256 4257 if (clang_isDeclaration(C.kind)) { 4258 const Decl *D = cxcursor::getCursorDecl(C); 4259 if (!D) 4260 return SourceRange(); 4261 4262 SourceRange R = D->getSourceRange(); 4263 // FIXME: Multiple variables declared in a single declaration 4264 // currently lack the information needed to correctly determine their 4265 // ranges when accounting for the type-specifier. We use context 4266 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 4267 // and if so, whether it is the first decl. 4268 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 4269 if (!cxcursor::isFirstInDeclGroup(C)) 4270 R.setBegin(VD->getLocation()); 4271 } 4272 return R; 4273 } 4274 return SourceRange(); 4275} 4276 4277/// \brief Retrieves the "raw" cursor extent, which is then extended to include 4278/// the decl-specifier-seq for declarations. 4279static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) { 4280 if (clang_isDeclaration(C.kind)) { 4281 const Decl *D = cxcursor::getCursorDecl(C); 4282 if (!D) 4283 return SourceRange(); 4284 4285 SourceRange R = D->getSourceRange(); 4286 4287 // Adjust the start of the location for declarations preceded by 4288 // declaration specifiers. 4289 SourceLocation StartLoc; 4290 if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) { 4291 if (TypeSourceInfo *TI = DD->getTypeSourceInfo()) 4292 StartLoc = TI->getTypeLoc().getLocStart(); 4293 } else if (const TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) { 4294 if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo()) 4295 StartLoc = TI->getTypeLoc().getLocStart(); 4296 } 4297 4298 if (StartLoc.isValid() && R.getBegin().isValid() && 4299 SrcMgr.isBeforeInTranslationUnit(StartLoc, R.getBegin())) 4300 R.setBegin(StartLoc); 4301 4302 // FIXME: Multiple variables declared in a single declaration 4303 // currently lack the information needed to correctly determine their 4304 // ranges when accounting for the type-specifier. We use context 4305 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 4306 // and if so, whether it is the first decl. 4307 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 4308 if (!cxcursor::isFirstInDeclGroup(C)) 4309 R.setBegin(VD->getLocation()); 4310 } 4311 4312 return R; 4313 } 4314 4315 return getRawCursorExtent(C); 4316} 4317 4318extern "C" { 4319 4320CXSourceRange clang_getCursorExtent(CXCursor C) { 4321 SourceRange R = getRawCursorExtent(C); 4322 if (R.isInvalid()) 4323 return clang_getNullRange(); 4324 4325 return cxloc::translateSourceRange(getCursorContext(C), R); 4326} 4327 4328CXCursor clang_getCursorReferenced(CXCursor C) { 4329 if (clang_isInvalid(C.kind)) 4330 return clang_getNullCursor(); 4331 4332 CXTranslationUnit tu = getCursorTU(C); 4333 if (clang_isDeclaration(C.kind)) { 4334 const Decl *D = getCursorDecl(C); 4335 if (!D) 4336 return clang_getNullCursor(); 4337 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) 4338 return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu); 4339 if (const ObjCPropertyImplDecl *PropImpl = 4340 dyn_cast<ObjCPropertyImplDecl>(D)) 4341 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 4342 return MakeCXCursor(Property, tu); 4343 4344 return C; 4345 } 4346 4347 if (clang_isExpression(C.kind)) { 4348 const Expr *E = getCursorExpr(C); 4349 const Decl *D = getDeclFromExpr(E); 4350 if (D) { 4351 CXCursor declCursor = MakeCXCursor(D, tu); 4352 declCursor = getSelectorIdentifierCursor(getSelectorIdentifierIndex(C), 4353 declCursor); 4354 return declCursor; 4355 } 4356 4357 if (const OverloadExpr *Ovl = dyn_cast_or_null<OverloadExpr>(E)) 4358 return MakeCursorOverloadedDeclRef(Ovl, tu); 4359 4360 return clang_getNullCursor(); 4361 } 4362 4363 if (clang_isStatement(C.kind)) { 4364 const Stmt *S = getCursorStmt(C); 4365 if (const GotoStmt *Goto = dyn_cast_or_null<GotoStmt>(S)) 4366 if (LabelDecl *label = Goto->getLabel()) 4367 if (LabelStmt *labelS = label->getStmt()) 4368 return MakeCXCursor(labelS, getCursorDecl(C), tu); 4369 4370 return clang_getNullCursor(); 4371 } 4372 4373 if (C.kind == CXCursor_MacroExpansion) { 4374 if (const MacroDefinition *Def = getCursorMacroExpansion(C).getDefinition()) 4375 return MakeMacroDefinitionCursor(Def, tu); 4376 } 4377 4378 if (!clang_isReference(C.kind)) 4379 return clang_getNullCursor(); 4380 4381 switch (C.kind) { 4382 case CXCursor_ObjCSuperClassRef: 4383 return MakeCXCursor(getCursorObjCSuperClassRef(C).first, tu); 4384 4385 case CXCursor_ObjCProtocolRef: { 4386 const ObjCProtocolDecl *Prot = getCursorObjCProtocolRef(C).first; 4387 if (const ObjCProtocolDecl *Def = Prot->getDefinition()) 4388 return MakeCXCursor(Def, tu); 4389 4390 return MakeCXCursor(Prot, tu); 4391 } 4392 4393 case CXCursor_ObjCClassRef: { 4394 const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first; 4395 if (const ObjCInterfaceDecl *Def = Class->getDefinition()) 4396 return MakeCXCursor(Def, tu); 4397 4398 return MakeCXCursor(Class, tu); 4399 } 4400 4401 case CXCursor_TypeRef: 4402 return MakeCXCursor(getCursorTypeRef(C).first, tu ); 4403 4404 case CXCursor_TemplateRef: 4405 return MakeCXCursor(getCursorTemplateRef(C).first, tu ); 4406 4407 case CXCursor_NamespaceRef: 4408 return MakeCXCursor(getCursorNamespaceRef(C).first, tu ); 4409 4410 case CXCursor_MemberRef: 4411 return MakeCXCursor(getCursorMemberRef(C).first, tu ); 4412 4413 case CXCursor_CXXBaseSpecifier: { 4414 const CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C); 4415 return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(), 4416 tu )); 4417 } 4418 4419 case CXCursor_LabelRef: 4420 // FIXME: We end up faking the "parent" declaration here because we 4421 // don't want to make CXCursor larger. 4422 return MakeCXCursor(getCursorLabelRef(C).first, 4423 cxtu::getASTUnit(tu)->getASTContext() 4424 .getTranslationUnitDecl(), 4425 tu); 4426 4427 case CXCursor_OverloadedDeclRef: 4428 return C; 4429 4430 case CXCursor_VariableRef: 4431 return MakeCXCursor(getCursorVariableRef(C).first, tu); 4432 4433 default: 4434 // We would prefer to enumerate all non-reference cursor kinds here. 4435 llvm_unreachable("Unhandled reference cursor kind"); 4436 } 4437} 4438 4439CXCursor clang_getCursorDefinition(CXCursor C) { 4440 if (clang_isInvalid(C.kind)) 4441 return clang_getNullCursor(); 4442 4443 CXTranslationUnit TU = getCursorTU(C); 4444 4445 bool WasReference = false; 4446 if (clang_isReference(C.kind) || clang_isExpression(C.kind)) { 4447 C = clang_getCursorReferenced(C); 4448 WasReference = true; 4449 } 4450 4451 if (C.kind == CXCursor_MacroExpansion) 4452 return clang_getCursorReferenced(C); 4453 4454 if (!clang_isDeclaration(C.kind)) 4455 return clang_getNullCursor(); 4456 4457 const Decl *D = getCursorDecl(C); 4458 if (!D) 4459 return clang_getNullCursor(); 4460 4461 switch (D->getKind()) { 4462 // Declaration kinds that don't really separate the notions of 4463 // declaration and definition. 4464 case Decl::Namespace: 4465 case Decl::Typedef: 4466 case Decl::TypeAlias: 4467 case Decl::TypeAliasTemplate: 4468 case Decl::TemplateTypeParm: 4469 case Decl::EnumConstant: 4470 case Decl::Field: 4471 case Decl::MSProperty: 4472 case Decl::IndirectField: 4473 case Decl::ObjCIvar: 4474 case Decl::ObjCAtDefsField: 4475 case Decl::ImplicitParam: 4476 case Decl::ParmVar: 4477 case Decl::NonTypeTemplateParm: 4478 case Decl::TemplateTemplateParm: 4479 case Decl::ObjCCategoryImpl: 4480 case Decl::ObjCImplementation: 4481 case Decl::AccessSpec: 4482 case Decl::LinkageSpec: 4483 case Decl::ObjCPropertyImpl: 4484 case Decl::FileScopeAsm: 4485 case Decl::StaticAssert: 4486 case Decl::Block: 4487 case Decl::Captured: 4488 case Decl::Label: // FIXME: Is this right?? 4489 case Decl::ClassScopeFunctionSpecialization: 4490 case Decl::Import: 4491 case Decl::OMPThreadPrivate: 4492 return C; 4493 4494 // Declaration kinds that don't make any sense here, but are 4495 // nonetheless harmless. 4496 case Decl::Empty: 4497 case Decl::TranslationUnit: 4498 break; 4499 4500 // Declaration kinds for which the definition is not resolvable. 4501 case Decl::UnresolvedUsingTypename: 4502 case Decl::UnresolvedUsingValue: 4503 break; 4504 4505 case Decl::UsingDirective: 4506 return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(), 4507 TU); 4508 4509 case Decl::NamespaceAlias: 4510 return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), TU); 4511 4512 case Decl::Enum: 4513 case Decl::Record: 4514 case Decl::CXXRecord: 4515 case Decl::ClassTemplateSpecialization: 4516 case Decl::ClassTemplatePartialSpecialization: 4517 if (TagDecl *Def = cast<TagDecl>(D)->getDefinition()) 4518 return MakeCXCursor(Def, TU); 4519 return clang_getNullCursor(); 4520 4521 case Decl::Function: 4522 case Decl::CXXMethod: 4523 case Decl::CXXConstructor: 4524 case Decl::CXXDestructor: 4525 case Decl::CXXConversion: { 4526 const FunctionDecl *Def = 0; 4527 if (cast<FunctionDecl>(D)->getBody(Def)) 4528 return MakeCXCursor(Def, TU); 4529 return clang_getNullCursor(); 4530 } 4531 4532 case Decl::Var: { 4533 // Ask the variable if it has a definition. 4534 if (const VarDecl *Def = cast<VarDecl>(D)->getDefinition()) 4535 return MakeCXCursor(Def, TU); 4536 return clang_getNullCursor(); 4537 } 4538 4539 case Decl::FunctionTemplate: { 4540 const FunctionDecl *Def = 0; 4541 if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def)) 4542 return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU); 4543 return clang_getNullCursor(); 4544 } 4545 4546 case Decl::ClassTemplate: { 4547 if (RecordDecl *Def = cast<ClassTemplateDecl>(D)->getTemplatedDecl() 4548 ->getDefinition()) 4549 return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(), 4550 TU); 4551 return clang_getNullCursor(); 4552 } 4553 4554 case Decl::Using: 4555 return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D), 4556 D->getLocation(), TU); 4557 4558 case Decl::UsingShadow: 4559 return clang_getCursorDefinition( 4560 MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(), 4561 TU)); 4562 4563 case Decl::ObjCMethod: { 4564 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D); 4565 if (Method->isThisDeclarationADefinition()) 4566 return C; 4567 4568 // Dig out the method definition in the associated 4569 // @implementation, if we have it. 4570 // FIXME: The ASTs should make finding the definition easier. 4571 if (const ObjCInterfaceDecl *Class 4572 = dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) 4573 if (ObjCImplementationDecl *ClassImpl = Class->getImplementation()) 4574 if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(), 4575 Method->isInstanceMethod())) 4576 if (Def->isThisDeclarationADefinition()) 4577 return MakeCXCursor(Def, TU); 4578 4579 return clang_getNullCursor(); 4580 } 4581 4582 case Decl::ObjCCategory: 4583 if (ObjCCategoryImplDecl *Impl 4584 = cast<ObjCCategoryDecl>(D)->getImplementation()) 4585 return MakeCXCursor(Impl, TU); 4586 return clang_getNullCursor(); 4587 4588 case Decl::ObjCProtocol: 4589 if (const ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(D)->getDefinition()) 4590 return MakeCXCursor(Def, TU); 4591 return clang_getNullCursor(); 4592 4593 case Decl::ObjCInterface: { 4594 // There are two notions of a "definition" for an Objective-C 4595 // class: the interface and its implementation. When we resolved a 4596 // reference to an Objective-C class, produce the @interface as 4597 // the definition; when we were provided with the interface, 4598 // produce the @implementation as the definition. 4599 const ObjCInterfaceDecl *IFace = cast<ObjCInterfaceDecl>(D); 4600 if (WasReference) { 4601 if (const ObjCInterfaceDecl *Def = IFace->getDefinition()) 4602 return MakeCXCursor(Def, TU); 4603 } else if (ObjCImplementationDecl *Impl = IFace->getImplementation()) 4604 return MakeCXCursor(Impl, TU); 4605 return clang_getNullCursor(); 4606 } 4607 4608 case Decl::ObjCProperty: 4609 // FIXME: We don't really know where to find the 4610 // ObjCPropertyImplDecls that implement this property. 4611 return clang_getNullCursor(); 4612 4613 case Decl::ObjCCompatibleAlias: 4614 if (const ObjCInterfaceDecl *Class 4615 = cast<ObjCCompatibleAliasDecl>(D)->getClassInterface()) 4616 if (const ObjCInterfaceDecl *Def = Class->getDefinition()) 4617 return MakeCXCursor(Def, TU); 4618 4619 return clang_getNullCursor(); 4620 4621 case Decl::Friend: 4622 if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl()) 4623 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 4624 return clang_getNullCursor(); 4625 4626 case Decl::FriendTemplate: 4627 if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl()) 4628 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 4629 return clang_getNullCursor(); 4630 } 4631 4632 return clang_getNullCursor(); 4633} 4634 4635unsigned clang_isCursorDefinition(CXCursor C) { 4636 if (!clang_isDeclaration(C.kind)) 4637 return 0; 4638 4639 return clang_getCursorDefinition(C) == C; 4640} 4641 4642CXCursor clang_getCanonicalCursor(CXCursor C) { 4643 if (!clang_isDeclaration(C.kind)) 4644 return C; 4645 4646 if (const Decl *D = getCursorDecl(C)) { 4647 if (const ObjCCategoryImplDecl *CatImplD = dyn_cast<ObjCCategoryImplDecl>(D)) 4648 if (ObjCCategoryDecl *CatD = CatImplD->getCategoryDecl()) 4649 return MakeCXCursor(CatD, getCursorTU(C)); 4650 4651 if (const ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 4652 if (const ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) 4653 return MakeCXCursor(IFD, getCursorTU(C)); 4654 4655 return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C)); 4656 } 4657 4658 return C; 4659} 4660 4661int clang_Cursor_getObjCSelectorIndex(CXCursor cursor) { 4662 return cxcursor::getSelectorIdentifierIndexAndLoc(cursor).first; 4663} 4664 4665unsigned clang_getNumOverloadedDecls(CXCursor C) { 4666 if (C.kind != CXCursor_OverloadedDeclRef) 4667 return 0; 4668 4669 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 4670 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>()) 4671 return E->getNumDecls(); 4672 4673 if (OverloadedTemplateStorage *S 4674 = Storage.dyn_cast<OverloadedTemplateStorage*>()) 4675 return S->size(); 4676 4677 const Decl *D = Storage.get<const Decl *>(); 4678 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) 4679 return Using->shadow_size(); 4680 4681 return 0; 4682} 4683 4684CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) { 4685 if (cursor.kind != CXCursor_OverloadedDeclRef) 4686 return clang_getNullCursor(); 4687 4688 if (index >= clang_getNumOverloadedDecls(cursor)) 4689 return clang_getNullCursor(); 4690 4691 CXTranslationUnit TU = getCursorTU(cursor); 4692 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first; 4693 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>()) 4694 return MakeCXCursor(E->decls_begin()[index], TU); 4695 4696 if (OverloadedTemplateStorage *S 4697 = Storage.dyn_cast<OverloadedTemplateStorage*>()) 4698 return MakeCXCursor(S->begin()[index], TU); 4699 4700 const Decl *D = Storage.get<const Decl *>(); 4701 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) { 4702 // FIXME: This is, unfortunately, linear time. 4703 UsingDecl::shadow_iterator Pos = Using->shadow_begin(); 4704 std::advance(Pos, index); 4705 return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU); 4706 } 4707 4708 return clang_getNullCursor(); 4709} 4710 4711void clang_getDefinitionSpellingAndExtent(CXCursor C, 4712 const char **startBuf, 4713 const char **endBuf, 4714 unsigned *startLine, 4715 unsigned *startColumn, 4716 unsigned *endLine, 4717 unsigned *endColumn) { 4718 assert(getCursorDecl(C) && "CXCursor has null decl"); 4719 const FunctionDecl *FD = dyn_cast<FunctionDecl>(getCursorDecl(C)); 4720 CompoundStmt *Body = dyn_cast<CompoundStmt>(FD->getBody()); 4721 4722 SourceManager &SM = FD->getASTContext().getSourceManager(); 4723 *startBuf = SM.getCharacterData(Body->getLBracLoc()); 4724 *endBuf = SM.getCharacterData(Body->getRBracLoc()); 4725 *startLine = SM.getSpellingLineNumber(Body->getLBracLoc()); 4726 *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc()); 4727 *endLine = SM.getSpellingLineNumber(Body->getRBracLoc()); 4728 *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc()); 4729} 4730 4731 4732CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags, 4733 unsigned PieceIndex) { 4734 RefNamePieces Pieces; 4735 4736 switch (C.kind) { 4737 case CXCursor_MemberRefExpr: 4738 if (const MemberExpr *E = dyn_cast<MemberExpr>(getCursorExpr(C))) 4739 Pieces = buildPieces(NameFlags, true, E->getMemberNameInfo(), 4740 E->getQualifierLoc().getSourceRange()); 4741 break; 4742 4743 case CXCursor_DeclRefExpr: 4744 if (const DeclRefExpr *E = dyn_cast<DeclRefExpr>(getCursorExpr(C))) 4745 Pieces = buildPieces(NameFlags, false, E->getNameInfo(), 4746 E->getQualifierLoc().getSourceRange(), 4747 E->getOptionalExplicitTemplateArgs()); 4748 break; 4749 4750 case CXCursor_CallExpr: 4751 if (const CXXOperatorCallExpr *OCE = 4752 dyn_cast<CXXOperatorCallExpr>(getCursorExpr(C))) { 4753 const Expr *Callee = OCE->getCallee(); 4754 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee)) 4755 Callee = ICE->getSubExpr(); 4756 4757 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) 4758 Pieces = buildPieces(NameFlags, false, DRE->getNameInfo(), 4759 DRE->getQualifierLoc().getSourceRange()); 4760 } 4761 break; 4762 4763 default: 4764 break; 4765 } 4766 4767 if (Pieces.empty()) { 4768 if (PieceIndex == 0) 4769 return clang_getCursorExtent(C); 4770 } else if (PieceIndex < Pieces.size()) { 4771 SourceRange R = Pieces[PieceIndex]; 4772 if (R.isValid()) 4773 return cxloc::translateSourceRange(getCursorContext(C), R); 4774 } 4775 4776 return clang_getNullRange(); 4777} 4778 4779void clang_enableStackTraces(void) { 4780 llvm::sys::PrintStackTraceOnErrorSignal(); 4781} 4782 4783void clang_executeOnThread(void (*fn)(void*), void *user_data, 4784 unsigned stack_size) { 4785 llvm::llvm_execute_on_thread(fn, user_data, stack_size); 4786} 4787 4788} // end: extern "C" 4789 4790//===----------------------------------------------------------------------===// 4791// Token-based Operations. 4792//===----------------------------------------------------------------------===// 4793 4794/* CXToken layout: 4795 * int_data[0]: a CXTokenKind 4796 * int_data[1]: starting token location 4797 * int_data[2]: token length 4798 * int_data[3]: reserved 4799 * ptr_data: for identifiers and keywords, an IdentifierInfo*. 4800 * otherwise unused. 4801 */ 4802extern "C" { 4803 4804CXTokenKind clang_getTokenKind(CXToken CXTok) { 4805 return static_cast<CXTokenKind>(CXTok.int_data[0]); 4806} 4807 4808CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) { 4809 switch (clang_getTokenKind(CXTok)) { 4810 case CXToken_Identifier: 4811 case CXToken_Keyword: 4812 // We know we have an IdentifierInfo*, so use that. 4813 return cxstring::createRef(static_cast<IdentifierInfo *>(CXTok.ptr_data) 4814 ->getNameStart()); 4815 4816 case CXToken_Literal: { 4817 // We have stashed the starting pointer in the ptr_data field. Use it. 4818 const char *Text = static_cast<const char *>(CXTok.ptr_data); 4819 return cxstring::createDup(StringRef(Text, CXTok.int_data[2])); 4820 } 4821 4822 case CXToken_Punctuation: 4823 case CXToken_Comment: 4824 break; 4825 } 4826 4827 // We have to find the starting buffer pointer the hard way, by 4828 // deconstructing the source location. 4829 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4830 if (!CXXUnit) 4831 return cxstring::createEmpty(); 4832 4833 SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]); 4834 std::pair<FileID, unsigned> LocInfo 4835 = CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc); 4836 bool Invalid = false; 4837 StringRef Buffer 4838 = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid); 4839 if (Invalid) 4840 return cxstring::createEmpty(); 4841 4842 return cxstring::createDup(Buffer.substr(LocInfo.second, CXTok.int_data[2])); 4843} 4844 4845CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) { 4846 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4847 if (!CXXUnit) 4848 return clang_getNullLocation(); 4849 4850 return cxloc::translateSourceLocation(CXXUnit->getASTContext(), 4851 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 4852} 4853 4854CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) { 4855 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4856 if (!CXXUnit) 4857 return clang_getNullRange(); 4858 4859 return cxloc::translateSourceRange(CXXUnit->getASTContext(), 4860 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 4861} 4862 4863static void getTokens(ASTUnit *CXXUnit, SourceRange Range, 4864 SmallVectorImpl<CXToken> &CXTokens) { 4865 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 4866 std::pair<FileID, unsigned> BeginLocInfo 4867 = SourceMgr.getDecomposedSpellingLoc(Range.getBegin()); 4868 std::pair<FileID, unsigned> EndLocInfo 4869 = SourceMgr.getDecomposedSpellingLoc(Range.getEnd()); 4870 4871 // Cannot tokenize across files. 4872 if (BeginLocInfo.first != EndLocInfo.first) 4873 return; 4874 4875 // Create a lexer 4876 bool Invalid = false; 4877 StringRef Buffer 4878 = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid); 4879 if (Invalid) 4880 return; 4881 4882 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 4883 CXXUnit->getASTContext().getLangOpts(), 4884 Buffer.begin(), Buffer.data() + BeginLocInfo.second, Buffer.end()); 4885 Lex.SetCommentRetentionState(true); 4886 4887 // Lex tokens until we hit the end of the range. 4888 const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second; 4889 Token Tok; 4890 bool previousWasAt = false; 4891 do { 4892 // Lex the next token 4893 Lex.LexFromRawLexer(Tok); 4894 if (Tok.is(tok::eof)) 4895 break; 4896 4897 // Initialize the CXToken. 4898 CXToken CXTok; 4899 4900 // - Common fields 4901 CXTok.int_data[1] = Tok.getLocation().getRawEncoding(); 4902 CXTok.int_data[2] = Tok.getLength(); 4903 CXTok.int_data[3] = 0; 4904 4905 // - Kind-specific fields 4906 if (Tok.isLiteral()) { 4907 CXTok.int_data[0] = CXToken_Literal; 4908 CXTok.ptr_data = const_cast<char *>(Tok.getLiteralData()); 4909 } else if (Tok.is(tok::raw_identifier)) { 4910 // Lookup the identifier to determine whether we have a keyword. 4911 IdentifierInfo *II 4912 = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok); 4913 4914 if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) { 4915 CXTok.int_data[0] = CXToken_Keyword; 4916 } 4917 else { 4918 CXTok.int_data[0] = Tok.is(tok::identifier) 4919 ? CXToken_Identifier 4920 : CXToken_Keyword; 4921 } 4922 CXTok.ptr_data = II; 4923 } else if (Tok.is(tok::comment)) { 4924 CXTok.int_data[0] = CXToken_Comment; 4925 CXTok.ptr_data = 0; 4926 } else { 4927 CXTok.int_data[0] = CXToken_Punctuation; 4928 CXTok.ptr_data = 0; 4929 } 4930 CXTokens.push_back(CXTok); 4931 previousWasAt = Tok.is(tok::at); 4932 } while (Lex.getBufferLocation() <= EffectiveBufferEnd); 4933} 4934 4935void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range, 4936 CXToken **Tokens, unsigned *NumTokens) { 4937 LOG_FUNC_SECTION { 4938 *Log << TU << ' ' << Range; 4939 } 4940 4941 if (Tokens) 4942 *Tokens = 0; 4943 if (NumTokens) 4944 *NumTokens = 0; 4945 4946 if (!TU) 4947 return; 4948 4949 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4950 if (!CXXUnit || !Tokens || !NumTokens) 4951 return; 4952 4953 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 4954 4955 SourceRange R = cxloc::translateCXSourceRange(Range); 4956 if (R.isInvalid()) 4957 return; 4958 4959 SmallVector<CXToken, 32> CXTokens; 4960 getTokens(CXXUnit, R, CXTokens); 4961 4962 if (CXTokens.empty()) 4963 return; 4964 4965 *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size()); 4966 memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size()); 4967 *NumTokens = CXTokens.size(); 4968} 4969 4970void clang_disposeTokens(CXTranslationUnit TU, 4971 CXToken *Tokens, unsigned NumTokens) { 4972 free(Tokens); 4973} 4974 4975} // end: extern "C" 4976 4977//===----------------------------------------------------------------------===// 4978// Token annotation APIs. 4979//===----------------------------------------------------------------------===// 4980 4981static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 4982 CXCursor parent, 4983 CXClientData client_data); 4984static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor, 4985 CXClientData client_data); 4986 4987namespace { 4988class AnnotateTokensWorker { 4989 CXToken *Tokens; 4990 CXCursor *Cursors; 4991 unsigned NumTokens; 4992 unsigned TokIdx; 4993 unsigned PreprocessingTokIdx; 4994 CursorVisitor AnnotateVis; 4995 SourceManager &SrcMgr; 4996 bool HasContextSensitiveKeywords; 4997 4998 struct PostChildrenInfo { 4999 CXCursor Cursor; 5000 SourceRange CursorRange; 5001 unsigned BeforeReachingCursorIdx; 5002 unsigned BeforeChildrenTokenIdx; 5003 }; 5004 SmallVector<PostChildrenInfo, 8> PostChildrenInfos; 5005 5006 bool MoreTokens() const { return TokIdx < NumTokens; } 5007 unsigned NextToken() const { return TokIdx; } 5008 void AdvanceToken() { ++TokIdx; } 5009 SourceLocation GetTokenLoc(unsigned tokI) { 5010 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]); 5011 } 5012 bool isFunctionMacroToken(unsigned tokI) const { 5013 return Tokens[tokI].int_data[3] != 0; 5014 } 5015 SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const { 5016 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[3]); 5017 } 5018 5019 void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange); 5020 bool annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult, 5021 SourceRange); 5022 5023public: 5024 AnnotateTokensWorker(CXToken *tokens, CXCursor *cursors, unsigned numTokens, 5025 CXTranslationUnit TU, SourceRange RegionOfInterest) 5026 : Tokens(tokens), Cursors(cursors), 5027 NumTokens(numTokens), TokIdx(0), PreprocessingTokIdx(0), 5028 AnnotateVis(TU, 5029 AnnotateTokensVisitor, this, 5030 /*VisitPreprocessorLast=*/true, 5031 /*VisitIncludedEntities=*/false, 5032 RegionOfInterest, 5033 /*VisitDeclsOnly=*/false, 5034 AnnotateTokensPostChildrenVisitor), 5035 SrcMgr(cxtu::getASTUnit(TU)->getSourceManager()), 5036 HasContextSensitiveKeywords(false) { } 5037 5038 void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); } 5039 enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent); 5040 bool postVisitChildren(CXCursor cursor); 5041 void AnnotateTokens(); 5042 5043 /// \brief Determine whether the annotator saw any cursors that have 5044 /// context-sensitive keywords. 5045 bool hasContextSensitiveKeywords() const { 5046 return HasContextSensitiveKeywords; 5047 } 5048 5049 ~AnnotateTokensWorker() { 5050 assert(PostChildrenInfos.empty()); 5051 } 5052}; 5053} 5054 5055void AnnotateTokensWorker::AnnotateTokens() { 5056 // Walk the AST within the region of interest, annotating tokens 5057 // along the way. 5058 AnnotateVis.visitFileRegion(); 5059} 5060 5061static inline void updateCursorAnnotation(CXCursor &Cursor, 5062 const CXCursor &updateC) { 5063 if (clang_isInvalid(updateC.kind) || !clang_isInvalid(Cursor.kind)) 5064 return; 5065 Cursor = updateC; 5066} 5067 5068/// \brief It annotates and advances tokens with a cursor until the comparison 5069//// between the cursor location and the source range is the same as 5070/// \arg compResult. 5071/// 5072/// Pass RangeBefore to annotate tokens with a cursor until a range is reached. 5073/// Pass RangeOverlap to annotate tokens inside a range. 5074void AnnotateTokensWorker::annotateAndAdvanceTokens(CXCursor updateC, 5075 RangeComparisonResult compResult, 5076 SourceRange range) { 5077 while (MoreTokens()) { 5078 const unsigned I = NextToken(); 5079 if (isFunctionMacroToken(I)) 5080 if (!annotateAndAdvanceFunctionMacroTokens(updateC, compResult, range)) 5081 return; 5082 5083 SourceLocation TokLoc = GetTokenLoc(I); 5084 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) { 5085 updateCursorAnnotation(Cursors[I], updateC); 5086 AdvanceToken(); 5087 continue; 5088 } 5089 break; 5090 } 5091} 5092 5093/// \brief Special annotation handling for macro argument tokens. 5094/// \returns true if it advanced beyond all macro tokens, false otherwise. 5095bool AnnotateTokensWorker::annotateAndAdvanceFunctionMacroTokens( 5096 CXCursor updateC, 5097 RangeComparisonResult compResult, 5098 SourceRange range) { 5099 assert(MoreTokens()); 5100 assert(isFunctionMacroToken(NextToken()) && 5101 "Should be called only for macro arg tokens"); 5102 5103 // This works differently than annotateAndAdvanceTokens; because expanded 5104 // macro arguments can have arbitrary translation-unit source order, we do not 5105 // advance the token index one by one until a token fails the range test. 5106 // We only advance once past all of the macro arg tokens if all of them 5107 // pass the range test. If one of them fails we keep the token index pointing 5108 // at the start of the macro arg tokens so that the failing token will be 5109 // annotated by a subsequent annotation try. 5110 5111 bool atLeastOneCompFail = false; 5112 5113 unsigned I = NextToken(); 5114 for (; I < NumTokens && isFunctionMacroToken(I); ++I) { 5115 SourceLocation TokLoc = getFunctionMacroTokenLoc(I); 5116 if (TokLoc.isFileID()) 5117 continue; // not macro arg token, it's parens or comma. 5118 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) { 5119 if (clang_isInvalid(clang_getCursorKind(Cursors[I]))) 5120 Cursors[I] = updateC; 5121 } else 5122 atLeastOneCompFail = true; 5123 } 5124 5125 if (atLeastOneCompFail) 5126 return false; 5127 5128 TokIdx = I; // All of the tokens were handled, advance beyond all of them. 5129 return true; 5130} 5131 5132enum CXChildVisitResult 5133AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) { 5134 SourceRange cursorRange = getRawCursorExtent(cursor); 5135 if (cursorRange.isInvalid()) 5136 return CXChildVisit_Recurse; 5137 5138 if (!HasContextSensitiveKeywords) { 5139 // Objective-C properties can have context-sensitive keywords. 5140 if (cursor.kind == CXCursor_ObjCPropertyDecl) { 5141 if (const ObjCPropertyDecl *Property 5142 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(cursor))) 5143 HasContextSensitiveKeywords = Property->getPropertyAttributesAsWritten() != 0; 5144 } 5145 // Objective-C methods can have context-sensitive keywords. 5146 else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl || 5147 cursor.kind == CXCursor_ObjCClassMethodDecl) { 5148 if (const ObjCMethodDecl *Method 5149 = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) { 5150 if (Method->getObjCDeclQualifier()) 5151 HasContextSensitiveKeywords = true; 5152 else { 5153 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(), 5154 PEnd = Method->param_end(); 5155 P != PEnd; ++P) { 5156 if ((*P)->getObjCDeclQualifier()) { 5157 HasContextSensitiveKeywords = true; 5158 break; 5159 } 5160 } 5161 } 5162 } 5163 } 5164 // C++ methods can have context-sensitive keywords. 5165 else if (cursor.kind == CXCursor_CXXMethod) { 5166 if (const CXXMethodDecl *Method 5167 = dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(cursor))) { 5168 if (Method->hasAttr<FinalAttr>() || Method->hasAttr<OverrideAttr>()) 5169 HasContextSensitiveKeywords = true; 5170 } 5171 } 5172 // C++ classes can have context-sensitive keywords. 5173 else if (cursor.kind == CXCursor_StructDecl || 5174 cursor.kind == CXCursor_ClassDecl || 5175 cursor.kind == CXCursor_ClassTemplate || 5176 cursor.kind == CXCursor_ClassTemplatePartialSpecialization) { 5177 if (const Decl *D = getCursorDecl(cursor)) 5178 if (D->hasAttr<FinalAttr>()) 5179 HasContextSensitiveKeywords = true; 5180 } 5181 } 5182 5183 if (clang_isPreprocessing(cursor.kind)) { 5184 // Items in the preprocessing record are kept separate from items in 5185 // declarations, so we keep a separate token index. 5186 unsigned SavedTokIdx = TokIdx; 5187 TokIdx = PreprocessingTokIdx; 5188 5189 // Skip tokens up until we catch up to the beginning of the preprocessing 5190 // entry. 5191 while (MoreTokens()) { 5192 const unsigned I = NextToken(); 5193 SourceLocation TokLoc = GetTokenLoc(I); 5194 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 5195 case RangeBefore: 5196 AdvanceToken(); 5197 continue; 5198 case RangeAfter: 5199 case RangeOverlap: 5200 break; 5201 } 5202 break; 5203 } 5204 5205 // Look at all of the tokens within this range. 5206 while (MoreTokens()) { 5207 const unsigned I = NextToken(); 5208 SourceLocation TokLoc = GetTokenLoc(I); 5209 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 5210 case RangeBefore: 5211 llvm_unreachable("Infeasible"); 5212 case RangeAfter: 5213 break; 5214 case RangeOverlap: 5215 // For macro expansions, just note where the beginning of the macro 5216 // expansion occurs. 5217 if (cursor.kind == CXCursor_MacroExpansion) { 5218 if (TokLoc == cursorRange.getBegin()) 5219 Cursors[I] = cursor; 5220 AdvanceToken(); 5221 break; 5222 } 5223 // We may have already annotated macro names inside macro definitions. 5224 if (Cursors[I].kind != CXCursor_MacroExpansion) 5225 Cursors[I] = cursor; 5226 AdvanceToken(); 5227 continue; 5228 } 5229 break; 5230 } 5231 5232 // Save the preprocessing token index; restore the non-preprocessing 5233 // token index. 5234 PreprocessingTokIdx = TokIdx; 5235 TokIdx = SavedTokIdx; 5236 return CXChildVisit_Recurse; 5237 } 5238 5239 if (cursorRange.isInvalid()) 5240 return CXChildVisit_Continue; 5241 5242 unsigned BeforeReachingCursorIdx = NextToken(); 5243 const enum CXCursorKind cursorK = clang_getCursorKind(cursor); 5244 const enum CXCursorKind K = clang_getCursorKind(parent); 5245 const CXCursor updateC = 5246 (clang_isInvalid(K) || K == CXCursor_TranslationUnit || 5247 // Attributes are annotated out-of-order, skip tokens until we reach it. 5248 clang_isAttribute(cursor.kind)) 5249 ? clang_getNullCursor() : parent; 5250 5251 annotateAndAdvanceTokens(updateC, RangeBefore, cursorRange); 5252 5253 // Avoid having the cursor of an expression "overwrite" the annotation of the 5254 // variable declaration that it belongs to. 5255 // This can happen for C++ constructor expressions whose range generally 5256 // include the variable declaration, e.g.: 5257 // MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor. 5258 if (clang_isExpression(cursorK)) { 5259 const Expr *E = getCursorExpr(cursor); 5260 if (const Decl *D = getCursorParentDecl(cursor)) { 5261 const unsigned I = NextToken(); 5262 if (E->getLocStart().isValid() && D->getLocation().isValid() && 5263 E->getLocStart() == D->getLocation() && 5264 E->getLocStart() == GetTokenLoc(I)) { 5265 updateCursorAnnotation(Cursors[I], updateC); 5266 AdvanceToken(); 5267 } 5268 } 5269 } 5270 5271 // Before recursing into the children keep some state that we are going 5272 // to use in the AnnotateTokensWorker::postVisitChildren callback to do some 5273 // extra work after the child nodes are visited. 5274 // Note that we don't call VisitChildren here to avoid traversing statements 5275 // code-recursively which can blow the stack. 5276 5277 PostChildrenInfo Info; 5278 Info.Cursor = cursor; 5279 Info.CursorRange = cursorRange; 5280 Info.BeforeReachingCursorIdx = BeforeReachingCursorIdx; 5281 Info.BeforeChildrenTokenIdx = NextToken(); 5282 PostChildrenInfos.push_back(Info); 5283 5284 return CXChildVisit_Recurse; 5285} 5286 5287bool AnnotateTokensWorker::postVisitChildren(CXCursor cursor) { 5288 if (PostChildrenInfos.empty()) 5289 return false; 5290 const PostChildrenInfo &Info = PostChildrenInfos.back(); 5291 if (!clang_equalCursors(Info.Cursor, cursor)) 5292 return false; 5293 5294 const unsigned BeforeChildren = Info.BeforeChildrenTokenIdx; 5295 const unsigned AfterChildren = NextToken(); 5296 SourceRange cursorRange = Info.CursorRange; 5297 5298 // Scan the tokens that are at the end of the cursor, but are not captured 5299 // but the child cursors. 5300 annotateAndAdvanceTokens(cursor, RangeOverlap, cursorRange); 5301 5302 // Scan the tokens that are at the beginning of the cursor, but are not 5303 // capture by the child cursors. 5304 for (unsigned I = BeforeChildren; I != AfterChildren; ++I) { 5305 if (!clang_isInvalid(clang_getCursorKind(Cursors[I]))) 5306 break; 5307 5308 Cursors[I] = cursor; 5309 } 5310 5311 // Attributes are annotated out-of-order, rewind TokIdx to when we first 5312 // encountered the attribute cursor. 5313 if (clang_isAttribute(cursor.kind)) 5314 TokIdx = Info.BeforeReachingCursorIdx; 5315 5316 PostChildrenInfos.pop_back(); 5317 return false; 5318} 5319 5320static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 5321 CXCursor parent, 5322 CXClientData client_data) { 5323 return static_cast<AnnotateTokensWorker*>(client_data)->Visit(cursor, parent); 5324} 5325 5326static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor, 5327 CXClientData client_data) { 5328 return static_cast<AnnotateTokensWorker*>(client_data)-> 5329 postVisitChildren(cursor); 5330} 5331 5332namespace { 5333 5334/// \brief Uses the macro expansions in the preprocessing record to find 5335/// and mark tokens that are macro arguments. This info is used by the 5336/// AnnotateTokensWorker. 5337class MarkMacroArgTokensVisitor { 5338 SourceManager &SM; 5339 CXToken *Tokens; 5340 unsigned NumTokens; 5341 unsigned CurIdx; 5342 5343public: 5344 MarkMacroArgTokensVisitor(SourceManager &SM, 5345 CXToken *tokens, unsigned numTokens) 5346 : SM(SM), Tokens(tokens), NumTokens(numTokens), CurIdx(0) { } 5347 5348 CXChildVisitResult visit(CXCursor cursor, CXCursor parent) { 5349 if (cursor.kind != CXCursor_MacroExpansion) 5350 return CXChildVisit_Continue; 5351 5352 SourceRange macroRange = getCursorMacroExpansion(cursor).getSourceRange(); 5353 if (macroRange.getBegin() == macroRange.getEnd()) 5354 return CXChildVisit_Continue; // it's not a function macro. 5355 5356 for (; CurIdx < NumTokens; ++CurIdx) { 5357 if (!SM.isBeforeInTranslationUnit(getTokenLoc(CurIdx), 5358 macroRange.getBegin())) 5359 break; 5360 } 5361 5362 if (CurIdx == NumTokens) 5363 return CXChildVisit_Break; 5364 5365 for (; CurIdx < NumTokens; ++CurIdx) { 5366 SourceLocation tokLoc = getTokenLoc(CurIdx); 5367 if (!SM.isBeforeInTranslationUnit(tokLoc, macroRange.getEnd())) 5368 break; 5369 5370 setFunctionMacroTokenLoc(CurIdx, SM.getMacroArgExpandedLocation(tokLoc)); 5371 } 5372 5373 if (CurIdx == NumTokens) 5374 return CXChildVisit_Break; 5375 5376 return CXChildVisit_Continue; 5377 } 5378 5379private: 5380 SourceLocation getTokenLoc(unsigned tokI) { 5381 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]); 5382 } 5383 5384 void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) { 5385 // The third field is reserved and currently not used. Use it here 5386 // to mark macro arg expanded tokens with their expanded locations. 5387 Tokens[tokI].int_data[3] = loc.getRawEncoding(); 5388 } 5389}; 5390 5391} // end anonymous namespace 5392 5393static CXChildVisitResult 5394MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent, 5395 CXClientData client_data) { 5396 return static_cast<MarkMacroArgTokensVisitor*>(client_data)->visit(cursor, 5397 parent); 5398} 5399 5400namespace { 5401 struct clang_annotateTokens_Data { 5402 CXTranslationUnit TU; 5403 ASTUnit *CXXUnit; 5404 CXToken *Tokens; 5405 unsigned NumTokens; 5406 CXCursor *Cursors; 5407 }; 5408} 5409 5410/// \brief Used by \c annotatePreprocessorTokens. 5411/// \returns true if lexing was finished, false otherwise. 5412static bool lexNext(Lexer &Lex, Token &Tok, 5413 unsigned &NextIdx, unsigned NumTokens) { 5414 if (NextIdx >= NumTokens) 5415 return true; 5416 5417 ++NextIdx; 5418 Lex.LexFromRawLexer(Tok); 5419 if (Tok.is(tok::eof)) 5420 return true; 5421 5422 return false; 5423} 5424 5425static void annotatePreprocessorTokens(CXTranslationUnit TU, 5426 SourceRange RegionOfInterest, 5427 CXCursor *Cursors, 5428 CXToken *Tokens, 5429 unsigned NumTokens) { 5430 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 5431 5432 Preprocessor &PP = CXXUnit->getPreprocessor(); 5433 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 5434 std::pair<FileID, unsigned> BeginLocInfo 5435 = SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getBegin()); 5436 std::pair<FileID, unsigned> EndLocInfo 5437 = SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getEnd()); 5438 5439 if (BeginLocInfo.first != EndLocInfo.first) 5440 return; 5441 5442 StringRef Buffer; 5443 bool Invalid = false; 5444 Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid); 5445 if (Buffer.empty() || Invalid) 5446 return; 5447 5448 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 5449 CXXUnit->getASTContext().getLangOpts(), 5450 Buffer.begin(), Buffer.data() + BeginLocInfo.second, 5451 Buffer.end()); 5452 Lex.SetCommentRetentionState(true); 5453 5454 unsigned NextIdx = 0; 5455 // Lex tokens in raw mode until we hit the end of the range, to avoid 5456 // entering #includes or expanding macros. 5457 while (true) { 5458 Token Tok; 5459 if (lexNext(Lex, Tok, NextIdx, NumTokens)) 5460 break; 5461 unsigned TokIdx = NextIdx-1; 5462 assert(Tok.getLocation() == 5463 SourceLocation::getFromRawEncoding(Tokens[TokIdx].int_data[1])); 5464 5465 reprocess: 5466 if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) { 5467 // We have found a preprocessing directive. Annotate the tokens 5468 // appropriately. 5469 // 5470 // FIXME: Some simple tests here could identify macro definitions and 5471 // #undefs, to provide specific cursor kinds for those. 5472 5473 SourceLocation BeginLoc = Tok.getLocation(); 5474 if (lexNext(Lex, Tok, NextIdx, NumTokens)) 5475 break; 5476 5477 MacroInfo *MI = 0; 5478 if (Tok.is(tok::raw_identifier) && 5479 StringRef(Tok.getRawIdentifierData(), Tok.getLength()) == "define") { 5480 if (lexNext(Lex, Tok, NextIdx, NumTokens)) 5481 break; 5482 5483 if (Tok.is(tok::raw_identifier)) { 5484 StringRef Name(Tok.getRawIdentifierData(), Tok.getLength()); 5485 IdentifierInfo &II = PP.getIdentifierTable().get(Name); 5486 SourceLocation MappedTokLoc = 5487 CXXUnit->mapLocationToPreamble(Tok.getLocation()); 5488 MI = getMacroInfo(II, MappedTokLoc, TU); 5489 } 5490 } 5491 5492 bool finished = false; 5493 do { 5494 if (lexNext(Lex, Tok, NextIdx, NumTokens)) { 5495 finished = true; 5496 break; 5497 } 5498 // If we are in a macro definition, check if the token was ever a 5499 // macro name and annotate it if that's the case. 5500 if (MI) { 5501 SourceLocation SaveLoc = Tok.getLocation(); 5502 Tok.setLocation(CXXUnit->mapLocationToPreamble(SaveLoc)); 5503 MacroDefinition *MacroDef = checkForMacroInMacroDefinition(MI,Tok,TU); 5504 Tok.setLocation(SaveLoc); 5505 if (MacroDef) 5506 Cursors[NextIdx-1] = MakeMacroExpansionCursor(MacroDef, 5507 Tok.getLocation(), TU); 5508 } 5509 } while (!Tok.isAtStartOfLine()); 5510 5511 unsigned LastIdx = finished ? NextIdx-1 : NextIdx-2; 5512 assert(TokIdx <= LastIdx); 5513 SourceLocation EndLoc = 5514 SourceLocation::getFromRawEncoding(Tokens[LastIdx].int_data[1]); 5515 CXCursor Cursor = 5516 MakePreprocessingDirectiveCursor(SourceRange(BeginLoc, EndLoc), TU); 5517 5518 for (; TokIdx <= LastIdx; ++TokIdx) 5519 updateCursorAnnotation(Cursors[TokIdx], Cursor); 5520 5521 if (finished) 5522 break; 5523 goto reprocess; 5524 } 5525 } 5526} 5527 5528// This gets run a separate thread to avoid stack blowout. 5529static void clang_annotateTokensImpl(void *UserData) { 5530 CXTranslationUnit TU = ((clang_annotateTokens_Data*)UserData)->TU; 5531 ASTUnit *CXXUnit = ((clang_annotateTokens_Data*)UserData)->CXXUnit; 5532 CXToken *Tokens = ((clang_annotateTokens_Data*)UserData)->Tokens; 5533 const unsigned NumTokens = ((clang_annotateTokens_Data*)UserData)->NumTokens; 5534 CXCursor *Cursors = ((clang_annotateTokens_Data*)UserData)->Cursors; 5535 5536 CIndexer *CXXIdx = TU->CIdx; 5537 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 5538 setThreadBackgroundPriority(); 5539 5540 // Determine the region of interest, which contains all of the tokens. 5541 SourceRange RegionOfInterest; 5542 RegionOfInterest.setBegin( 5543 cxloc::translateSourceLocation(clang_getTokenLocation(TU, Tokens[0]))); 5544 RegionOfInterest.setEnd( 5545 cxloc::translateSourceLocation(clang_getTokenLocation(TU, 5546 Tokens[NumTokens-1]))); 5547 5548 // Relex the tokens within the source range to look for preprocessing 5549 // directives. 5550 annotatePreprocessorTokens(TU, RegionOfInterest, Cursors, Tokens, NumTokens); 5551 5552 // If begin location points inside a macro argument, set it to the expansion 5553 // location so we can have the full context when annotating semantically. 5554 { 5555 SourceManager &SM = CXXUnit->getSourceManager(); 5556 SourceLocation Loc = 5557 SM.getMacroArgExpandedLocation(RegionOfInterest.getBegin()); 5558 if (Loc.isMacroID()) 5559 RegionOfInterest.setBegin(SM.getExpansionLoc(Loc)); 5560 } 5561 5562 if (CXXUnit->getPreprocessor().getPreprocessingRecord()) { 5563 // Search and mark tokens that are macro argument expansions. 5564 MarkMacroArgTokensVisitor Visitor(CXXUnit->getSourceManager(), 5565 Tokens, NumTokens); 5566 CursorVisitor MacroArgMarker(TU, 5567 MarkMacroArgTokensVisitorDelegate, &Visitor, 5568 /*VisitPreprocessorLast=*/true, 5569 /*VisitIncludedEntities=*/false, 5570 RegionOfInterest); 5571 MacroArgMarker.visitPreprocessedEntitiesInRegion(); 5572 } 5573 5574 // Annotate all of the source locations in the region of interest that map to 5575 // a specific cursor. 5576 AnnotateTokensWorker W(Tokens, Cursors, NumTokens, TU, RegionOfInterest); 5577 5578 // FIXME: We use a ridiculous stack size here because the data-recursion 5579 // algorithm uses a large stack frame than the non-data recursive version, 5580 // and AnnotationTokensWorker currently transforms the data-recursion 5581 // algorithm back into a traditional recursion by explicitly calling 5582 // VisitChildren(). We will need to remove this explicit recursive call. 5583 W.AnnotateTokens(); 5584 5585 // If we ran into any entities that involve context-sensitive keywords, 5586 // take another pass through the tokens to mark them as such. 5587 if (W.hasContextSensitiveKeywords()) { 5588 for (unsigned I = 0; I != NumTokens; ++I) { 5589 if (clang_getTokenKind(Tokens[I]) != CXToken_Identifier) 5590 continue; 5591 5592 if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) { 5593 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 5594 if (const ObjCPropertyDecl *Property 5595 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(Cursors[I]))) { 5596 if (Property->getPropertyAttributesAsWritten() != 0 && 5597 llvm::StringSwitch<bool>(II->getName()) 5598 .Case("readonly", true) 5599 .Case("assign", true) 5600 .Case("unsafe_unretained", true) 5601 .Case("readwrite", true) 5602 .Case("retain", true) 5603 .Case("copy", true) 5604 .Case("nonatomic", true) 5605 .Case("atomic", true) 5606 .Case("getter", true) 5607 .Case("setter", true) 5608 .Case("strong", true) 5609 .Case("weak", true) 5610 .Default(false)) 5611 Tokens[I].int_data[0] = CXToken_Keyword; 5612 } 5613 continue; 5614 } 5615 5616 if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl || 5617 Cursors[I].kind == CXCursor_ObjCClassMethodDecl) { 5618 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 5619 if (llvm::StringSwitch<bool>(II->getName()) 5620 .Case("in", true) 5621 .Case("out", true) 5622 .Case("inout", true) 5623 .Case("oneway", true) 5624 .Case("bycopy", true) 5625 .Case("byref", true) 5626 .Default(false)) 5627 Tokens[I].int_data[0] = CXToken_Keyword; 5628 continue; 5629 } 5630 5631 if (Cursors[I].kind == CXCursor_CXXFinalAttr || 5632 Cursors[I].kind == CXCursor_CXXOverrideAttr) { 5633 Tokens[I].int_data[0] = CXToken_Keyword; 5634 continue; 5635 } 5636 } 5637 } 5638} 5639 5640extern "C" { 5641 5642void clang_annotateTokens(CXTranslationUnit TU, 5643 CXToken *Tokens, unsigned NumTokens, 5644 CXCursor *Cursors) { 5645 if (!TU || NumTokens == 0 || !Tokens || !Cursors) { 5646 LOG_FUNC_SECTION { *Log << "<null input>"; } 5647 return; 5648 } 5649 5650 LOG_FUNC_SECTION { 5651 *Log << TU << ' '; 5652 CXSourceLocation bloc = clang_getTokenLocation(TU, Tokens[0]); 5653 CXSourceLocation eloc = clang_getTokenLocation(TU, Tokens[NumTokens-1]); 5654 *Log << clang_getRange(bloc, eloc); 5655 } 5656 5657 // Any token we don't specifically annotate will have a NULL cursor. 5658 CXCursor C = clang_getNullCursor(); 5659 for (unsigned I = 0; I != NumTokens; ++I) 5660 Cursors[I] = C; 5661 5662 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 5663 if (!CXXUnit) 5664 return; 5665 5666 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 5667 5668 clang_annotateTokens_Data data = { TU, CXXUnit, Tokens, NumTokens, Cursors }; 5669 llvm::CrashRecoveryContext CRC; 5670 if (!RunSafely(CRC, clang_annotateTokensImpl, &data, 5671 GetSafetyThreadStackSize() * 2)) { 5672 fprintf(stderr, "libclang: crash detected while annotating tokens\n"); 5673 } 5674} 5675 5676} // end: extern "C" 5677 5678//===----------------------------------------------------------------------===// 5679// Operations for querying linkage of a cursor. 5680//===----------------------------------------------------------------------===// 5681 5682extern "C" { 5683CXLinkageKind clang_getCursorLinkage(CXCursor cursor) { 5684 if (!clang_isDeclaration(cursor.kind)) 5685 return CXLinkage_Invalid; 5686 5687 const Decl *D = cxcursor::getCursorDecl(cursor); 5688 if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D)) 5689 switch (ND->getLinkageInternal()) { 5690 case NoLinkage: return CXLinkage_NoLinkage; 5691 case InternalLinkage: return CXLinkage_Internal; 5692 case UniqueExternalLinkage: return CXLinkage_UniqueExternal; 5693 case ExternalLinkage: return CXLinkage_External; 5694 }; 5695 5696 return CXLinkage_Invalid; 5697} 5698} // end: extern "C" 5699 5700//===----------------------------------------------------------------------===// 5701// Operations for querying language of a cursor. 5702//===----------------------------------------------------------------------===// 5703 5704static CXLanguageKind getDeclLanguage(const Decl *D) { 5705 if (!D) 5706 return CXLanguage_C; 5707 5708 switch (D->getKind()) { 5709 default: 5710 break; 5711 case Decl::ImplicitParam: 5712 case Decl::ObjCAtDefsField: 5713 case Decl::ObjCCategory: 5714 case Decl::ObjCCategoryImpl: 5715 case Decl::ObjCCompatibleAlias: 5716 case Decl::ObjCImplementation: 5717 case Decl::ObjCInterface: 5718 case Decl::ObjCIvar: 5719 case Decl::ObjCMethod: 5720 case Decl::ObjCProperty: 5721 case Decl::ObjCPropertyImpl: 5722 case Decl::ObjCProtocol: 5723 return CXLanguage_ObjC; 5724 case Decl::CXXConstructor: 5725 case Decl::CXXConversion: 5726 case Decl::CXXDestructor: 5727 case Decl::CXXMethod: 5728 case Decl::CXXRecord: 5729 case Decl::ClassTemplate: 5730 case Decl::ClassTemplatePartialSpecialization: 5731 case Decl::ClassTemplateSpecialization: 5732 case Decl::Friend: 5733 case Decl::FriendTemplate: 5734 case Decl::FunctionTemplate: 5735 case Decl::LinkageSpec: 5736 case Decl::Namespace: 5737 case Decl::NamespaceAlias: 5738 case Decl::NonTypeTemplateParm: 5739 case Decl::StaticAssert: 5740 case Decl::TemplateTemplateParm: 5741 case Decl::TemplateTypeParm: 5742 case Decl::UnresolvedUsingTypename: 5743 case Decl::UnresolvedUsingValue: 5744 case Decl::Using: 5745 case Decl::UsingDirective: 5746 case Decl::UsingShadow: 5747 return CXLanguage_CPlusPlus; 5748 } 5749 5750 return CXLanguage_C; 5751} 5752 5753extern "C" { 5754 5755enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) { 5756 if (clang_isDeclaration(cursor.kind)) 5757 if (const Decl *D = cxcursor::getCursorDecl(cursor)) { 5758 if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted()) 5759 return CXAvailability_Available; 5760 5761 switch (D->getAvailability()) { 5762 case AR_Available: 5763 case AR_NotYetIntroduced: 5764 return CXAvailability_Available; 5765 5766 case AR_Deprecated: 5767 return CXAvailability_Deprecated; 5768 5769 case AR_Unavailable: 5770 return CXAvailability_NotAvailable; 5771 } 5772 } 5773 5774 return CXAvailability_Available; 5775} 5776 5777static CXVersion convertVersion(VersionTuple In) { 5778 CXVersion Out = { -1, -1, -1 }; 5779 if (In.empty()) 5780 return Out; 5781 5782 Out.Major = In.getMajor(); 5783 5784 Optional<unsigned> Minor = In.getMinor(); 5785 if (Minor.hasValue()) 5786 Out.Minor = *Minor; 5787 else 5788 return Out; 5789 5790 Optional<unsigned> Subminor = In.getSubminor(); 5791 if (Subminor.hasValue()) 5792 Out.Subminor = *Subminor; 5793 5794 return Out; 5795} 5796 5797int clang_getCursorPlatformAvailability(CXCursor cursor, 5798 int *always_deprecated, 5799 CXString *deprecated_message, 5800 int *always_unavailable, 5801 CXString *unavailable_message, 5802 CXPlatformAvailability *availability, 5803 int availability_size) { 5804 if (always_deprecated) 5805 *always_deprecated = 0; 5806 if (deprecated_message) 5807 *deprecated_message = cxstring::createEmpty(); 5808 if (always_unavailable) 5809 *always_unavailable = 0; 5810 if (unavailable_message) 5811 *unavailable_message = cxstring::createEmpty(); 5812 5813 if (!clang_isDeclaration(cursor.kind)) 5814 return 0; 5815 5816 const Decl *D = cxcursor::getCursorDecl(cursor); 5817 if (!D) 5818 return 0; 5819 5820 int N = 0; 5821 for (Decl::attr_iterator A = D->attr_begin(), AEnd = D->attr_end(); A != AEnd; 5822 ++A) { 5823 if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(*A)) { 5824 if (always_deprecated) 5825 *always_deprecated = 1; 5826 if (deprecated_message) 5827 *deprecated_message = cxstring::createDup(Deprecated->getMessage()); 5828 continue; 5829 } 5830 5831 if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(*A)) { 5832 if (always_unavailable) 5833 *always_unavailable = 1; 5834 if (unavailable_message) { 5835 *unavailable_message = cxstring::createDup(Unavailable->getMessage()); 5836 } 5837 continue; 5838 } 5839 5840 if (AvailabilityAttr *Avail = dyn_cast<AvailabilityAttr>(*A)) { 5841 if (N < availability_size) { 5842 availability[N].Platform 5843 = cxstring::createDup(Avail->getPlatform()->getName()); 5844 availability[N].Introduced = convertVersion(Avail->getIntroduced()); 5845 availability[N].Deprecated = convertVersion(Avail->getDeprecated()); 5846 availability[N].Obsoleted = convertVersion(Avail->getObsoleted()); 5847 availability[N].Unavailable = Avail->getUnavailable(); 5848 availability[N].Message = cxstring::createDup(Avail->getMessage()); 5849 } 5850 ++N; 5851 } 5852 } 5853 5854 return N; 5855} 5856 5857void clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability) { 5858 clang_disposeString(availability->Platform); 5859 clang_disposeString(availability->Message); 5860} 5861 5862CXLanguageKind clang_getCursorLanguage(CXCursor cursor) { 5863 if (clang_isDeclaration(cursor.kind)) 5864 return getDeclLanguage(cxcursor::getCursorDecl(cursor)); 5865 5866 return CXLanguage_Invalid; 5867} 5868 5869 /// \brief If the given cursor is the "templated" declaration 5870 /// descibing a class or function template, return the class or 5871 /// function template. 5872static const Decl *maybeGetTemplateCursor(const Decl *D) { 5873 if (!D) 5874 return 0; 5875 5876 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 5877 if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate()) 5878 return FunTmpl; 5879 5880 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) 5881 if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate()) 5882 return ClassTmpl; 5883 5884 return D; 5885} 5886 5887CXCursor clang_getCursorSemanticParent(CXCursor cursor) { 5888 if (clang_isDeclaration(cursor.kind)) { 5889 if (const Decl *D = getCursorDecl(cursor)) { 5890 const DeclContext *DC = D->getDeclContext(); 5891 if (!DC) 5892 return clang_getNullCursor(); 5893 5894 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 5895 getCursorTU(cursor)); 5896 } 5897 } 5898 5899 if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) { 5900 if (const Decl *D = getCursorDecl(cursor)) 5901 return MakeCXCursor(D, getCursorTU(cursor)); 5902 } 5903 5904 return clang_getNullCursor(); 5905} 5906 5907CXCursor clang_getCursorLexicalParent(CXCursor cursor) { 5908 if (clang_isDeclaration(cursor.kind)) { 5909 if (const Decl *D = getCursorDecl(cursor)) { 5910 const DeclContext *DC = D->getLexicalDeclContext(); 5911 if (!DC) 5912 return clang_getNullCursor(); 5913 5914 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 5915 getCursorTU(cursor)); 5916 } 5917 } 5918 5919 // FIXME: Note that we can't easily compute the lexical context of a 5920 // statement or expression, so we return nothing. 5921 return clang_getNullCursor(); 5922} 5923 5924CXFile clang_getIncludedFile(CXCursor cursor) { 5925 if (cursor.kind != CXCursor_InclusionDirective) 5926 return 0; 5927 5928 const InclusionDirective *ID = getCursorInclusionDirective(cursor); 5929 return const_cast<FileEntry *>(ID->getFile()); 5930} 5931 5932unsigned clang_Cursor_getObjCPropertyAttributes(CXCursor C, unsigned reserved) { 5933 if (C.kind != CXCursor_ObjCPropertyDecl) 5934 return CXObjCPropertyAttr_noattr; 5935 5936 unsigned Result = CXObjCPropertyAttr_noattr; 5937 const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(getCursorDecl(C)); 5938 ObjCPropertyDecl::PropertyAttributeKind Attr = 5939 PD->getPropertyAttributesAsWritten(); 5940 5941#define SET_CXOBJCPROP_ATTR(A) \ 5942 if (Attr & ObjCPropertyDecl::OBJC_PR_##A) \ 5943 Result |= CXObjCPropertyAttr_##A 5944 SET_CXOBJCPROP_ATTR(readonly); 5945 SET_CXOBJCPROP_ATTR(getter); 5946 SET_CXOBJCPROP_ATTR(assign); 5947 SET_CXOBJCPROP_ATTR(readwrite); 5948 SET_CXOBJCPROP_ATTR(retain); 5949 SET_CXOBJCPROP_ATTR(copy); 5950 SET_CXOBJCPROP_ATTR(nonatomic); 5951 SET_CXOBJCPROP_ATTR(setter); 5952 SET_CXOBJCPROP_ATTR(atomic); 5953 SET_CXOBJCPROP_ATTR(weak); 5954 SET_CXOBJCPROP_ATTR(strong); 5955 SET_CXOBJCPROP_ATTR(unsafe_unretained); 5956#undef SET_CXOBJCPROP_ATTR 5957 5958 return Result; 5959} 5960 5961unsigned clang_Cursor_getObjCDeclQualifiers(CXCursor C) { 5962 if (!clang_isDeclaration(C.kind)) 5963 return CXObjCDeclQualifier_None; 5964 5965 Decl::ObjCDeclQualifier QT = Decl::OBJC_TQ_None; 5966 const Decl *D = getCursorDecl(C); 5967 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 5968 QT = MD->getObjCDeclQualifier(); 5969 else if (const ParmVarDecl *PD = dyn_cast<ParmVarDecl>(D)) 5970 QT = PD->getObjCDeclQualifier(); 5971 if (QT == Decl::OBJC_TQ_None) 5972 return CXObjCDeclQualifier_None; 5973 5974 unsigned Result = CXObjCDeclQualifier_None; 5975 if (QT & Decl::OBJC_TQ_In) Result |= CXObjCDeclQualifier_In; 5976 if (QT & Decl::OBJC_TQ_Inout) Result |= CXObjCDeclQualifier_Inout; 5977 if (QT & Decl::OBJC_TQ_Out) Result |= CXObjCDeclQualifier_Out; 5978 if (QT & Decl::OBJC_TQ_Bycopy) Result |= CXObjCDeclQualifier_Bycopy; 5979 if (QT & Decl::OBJC_TQ_Byref) Result |= CXObjCDeclQualifier_Byref; 5980 if (QT & Decl::OBJC_TQ_Oneway) Result |= CXObjCDeclQualifier_Oneway; 5981 5982 return Result; 5983} 5984 5985unsigned clang_Cursor_isVariadic(CXCursor C) { 5986 if (!clang_isDeclaration(C.kind)) 5987 return 0; 5988 5989 const Decl *D = getCursorDecl(C); 5990 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 5991 return FD->isVariadic(); 5992 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 5993 return MD->isVariadic(); 5994 5995 return 0; 5996} 5997 5998CXSourceRange clang_Cursor_getCommentRange(CXCursor C) { 5999 if (!clang_isDeclaration(C.kind)) 6000 return clang_getNullRange(); 6001 6002 const Decl *D = getCursorDecl(C); 6003 ASTContext &Context = getCursorContext(C); 6004 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 6005 if (!RC) 6006 return clang_getNullRange(); 6007 6008 return cxloc::translateSourceRange(Context, RC->getSourceRange()); 6009} 6010 6011CXString clang_Cursor_getRawCommentText(CXCursor C) { 6012 if (!clang_isDeclaration(C.kind)) 6013 return cxstring::createNull(); 6014 6015 const Decl *D = getCursorDecl(C); 6016 ASTContext &Context = getCursorContext(C); 6017 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 6018 StringRef RawText = RC ? RC->getRawText(Context.getSourceManager()) : 6019 StringRef(); 6020 6021 // Don't duplicate the string because RawText points directly into source 6022 // code. 6023 return cxstring::createRef(RawText); 6024} 6025 6026CXString clang_Cursor_getBriefCommentText(CXCursor C) { 6027 if (!clang_isDeclaration(C.kind)) 6028 return cxstring::createNull(); 6029 6030 const Decl *D = getCursorDecl(C); 6031 const ASTContext &Context = getCursorContext(C); 6032 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 6033 6034 if (RC) { 6035 StringRef BriefText = RC->getBriefText(Context); 6036 6037 // Don't duplicate the string because RawComment ensures that this memory 6038 // will not go away. 6039 return cxstring::createRef(BriefText); 6040 } 6041 6042 return cxstring::createNull(); 6043} 6044 6045CXComment clang_Cursor_getParsedComment(CXCursor C) { 6046 if (!clang_isDeclaration(C.kind)) 6047 return cxcomment::createCXComment(NULL, NULL); 6048 6049 const Decl *D = getCursorDecl(C); 6050 const ASTContext &Context = getCursorContext(C); 6051 const comments::FullComment *FC = Context.getCommentForDecl(D, /*PP=*/ NULL); 6052 6053 return cxcomment::createCXComment(FC, getCursorTU(C)); 6054} 6055 6056CXModule clang_Cursor_getModule(CXCursor C) { 6057 if (C.kind == CXCursor_ModuleImportDecl) { 6058 if (const ImportDecl *ImportD = 6059 dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) 6060 return ImportD->getImportedModule(); 6061 } 6062 6063 return 0; 6064} 6065 6066CXFile clang_Module_getASTFile(CXModule CXMod) { 6067 if (!CXMod) 6068 return 0; 6069 Module *Mod = static_cast<Module*>(CXMod); 6070 return const_cast<FileEntry *>(Mod->getASTFile()); 6071} 6072 6073CXModule clang_Module_getParent(CXModule CXMod) { 6074 if (!CXMod) 6075 return 0; 6076 Module *Mod = static_cast<Module*>(CXMod); 6077 return Mod->Parent; 6078} 6079 6080CXString clang_Module_getName(CXModule CXMod) { 6081 if (!CXMod) 6082 return cxstring::createEmpty(); 6083 Module *Mod = static_cast<Module*>(CXMod); 6084 return cxstring::createDup(Mod->Name); 6085} 6086 6087CXString clang_Module_getFullName(CXModule CXMod) { 6088 if (!CXMod) 6089 return cxstring::createEmpty(); 6090 Module *Mod = static_cast<Module*>(CXMod); 6091 return cxstring::createDup(Mod->getFullModuleName()); 6092} 6093 6094unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit TU, 6095 CXModule CXMod) { 6096 if (!TU || !CXMod) 6097 return 0; 6098 Module *Mod = static_cast<Module*>(CXMod); 6099 FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager(); 6100 ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr); 6101 return TopHeaders.size(); 6102} 6103 6104CXFile clang_Module_getTopLevelHeader(CXTranslationUnit TU, 6105 CXModule CXMod, unsigned Index) { 6106 if (!TU || !CXMod) 6107 return 0; 6108 Module *Mod = static_cast<Module*>(CXMod); 6109 FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager(); 6110 6111 ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr); 6112 if (Index < TopHeaders.size()) 6113 return const_cast<FileEntry *>(TopHeaders[Index]); 6114 6115 return 0; 6116} 6117 6118} // end: extern "C" 6119 6120//===----------------------------------------------------------------------===// 6121// C++ AST instrospection. 6122//===----------------------------------------------------------------------===// 6123 6124extern "C" { 6125unsigned clang_CXXMethod_isPureVirtual(CXCursor C) { 6126 if (!clang_isDeclaration(C.kind)) 6127 return 0; 6128 6129 const CXXMethodDecl *Method = 0; 6130 const Decl *D = cxcursor::getCursorDecl(C); 6131 if (const FunctionTemplateDecl *FunTmpl = 6132 dyn_cast_or_null<FunctionTemplateDecl>(D)) 6133 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl()); 6134 else 6135 Method = dyn_cast_or_null<CXXMethodDecl>(D); 6136 return (Method && Method->isVirtual() && Method->isPure()) ? 1 : 0; 6137} 6138 6139unsigned clang_CXXMethod_isStatic(CXCursor C) { 6140 if (!clang_isDeclaration(C.kind)) 6141 return 0; 6142 6143 const CXXMethodDecl *Method = 0; 6144 const Decl *D = cxcursor::getCursorDecl(C); 6145 if (const FunctionTemplateDecl *FunTmpl = 6146 dyn_cast_or_null<FunctionTemplateDecl>(D)) 6147 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl()); 6148 else 6149 Method = dyn_cast_or_null<CXXMethodDecl>(D); 6150 return (Method && Method->isStatic()) ? 1 : 0; 6151} 6152 6153unsigned clang_CXXMethod_isVirtual(CXCursor C) { 6154 if (!clang_isDeclaration(C.kind)) 6155 return 0; 6156 6157 const CXXMethodDecl *Method = 0; 6158 const Decl *D = cxcursor::getCursorDecl(C); 6159 if (const FunctionTemplateDecl *FunTmpl = 6160 dyn_cast_or_null<FunctionTemplateDecl>(D)) 6161 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl()); 6162 else 6163 Method = dyn_cast_or_null<CXXMethodDecl>(D); 6164 return (Method && Method->isVirtual()) ? 1 : 0; 6165} 6166} // end: extern "C" 6167 6168//===----------------------------------------------------------------------===// 6169// Attribute introspection. 6170//===----------------------------------------------------------------------===// 6171 6172extern "C" { 6173CXType clang_getIBOutletCollectionType(CXCursor C) { 6174 if (C.kind != CXCursor_IBOutletCollectionAttr) 6175 return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C)); 6176 6177 const IBOutletCollectionAttr *A = 6178 cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C)); 6179 6180 return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorTU(C)); 6181} 6182} // end: extern "C" 6183 6184//===----------------------------------------------------------------------===// 6185// Inspecting memory usage. 6186//===----------------------------------------------------------------------===// 6187 6188typedef std::vector<CXTUResourceUsageEntry> MemUsageEntries; 6189 6190static inline void createCXTUResourceUsageEntry(MemUsageEntries &entries, 6191 enum CXTUResourceUsageKind k, 6192 unsigned long amount) { 6193 CXTUResourceUsageEntry entry = { k, amount }; 6194 entries.push_back(entry); 6195} 6196 6197extern "C" { 6198 6199const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) { 6200 const char *str = ""; 6201 switch (kind) { 6202 case CXTUResourceUsage_AST: 6203 str = "ASTContext: expressions, declarations, and types"; 6204 break; 6205 case CXTUResourceUsage_Identifiers: 6206 str = "ASTContext: identifiers"; 6207 break; 6208 case CXTUResourceUsage_Selectors: 6209 str = "ASTContext: selectors"; 6210 break; 6211 case CXTUResourceUsage_GlobalCompletionResults: 6212 str = "Code completion: cached global results"; 6213 break; 6214 case CXTUResourceUsage_SourceManagerContentCache: 6215 str = "SourceManager: content cache allocator"; 6216 break; 6217 case CXTUResourceUsage_AST_SideTables: 6218 str = "ASTContext: side tables"; 6219 break; 6220 case CXTUResourceUsage_SourceManager_Membuffer_Malloc: 6221 str = "SourceManager: malloc'ed memory buffers"; 6222 break; 6223 case CXTUResourceUsage_SourceManager_Membuffer_MMap: 6224 str = "SourceManager: mmap'ed memory buffers"; 6225 break; 6226 case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc: 6227 str = "ExternalASTSource: malloc'ed memory buffers"; 6228 break; 6229 case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap: 6230 str = "ExternalASTSource: mmap'ed memory buffers"; 6231 break; 6232 case CXTUResourceUsage_Preprocessor: 6233 str = "Preprocessor: malloc'ed memory"; 6234 break; 6235 case CXTUResourceUsage_PreprocessingRecord: 6236 str = "Preprocessor: PreprocessingRecord"; 6237 break; 6238 case CXTUResourceUsage_SourceManager_DataStructures: 6239 str = "SourceManager: data structures and tables"; 6240 break; 6241 case CXTUResourceUsage_Preprocessor_HeaderSearch: 6242 str = "Preprocessor: header search tables"; 6243 break; 6244 } 6245 return str; 6246} 6247 6248CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU) { 6249 if (!TU) { 6250 CXTUResourceUsage usage = { (void*) 0, 0, 0 }; 6251 return usage; 6252 } 6253 6254 ASTUnit *astUnit = cxtu::getASTUnit(TU); 6255 OwningPtr<MemUsageEntries> entries(new MemUsageEntries()); 6256 ASTContext &astContext = astUnit->getASTContext(); 6257 6258 // How much memory is used by AST nodes and types? 6259 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST, 6260 (unsigned long) astContext.getASTAllocatedMemory()); 6261 6262 // How much memory is used by identifiers? 6263 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Identifiers, 6264 (unsigned long) astContext.Idents.getAllocator().getTotalMemory()); 6265 6266 // How much memory is used for selectors? 6267 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Selectors, 6268 (unsigned long) astContext.Selectors.getTotalMemory()); 6269 6270 // How much memory is used by ASTContext's side tables? 6271 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST_SideTables, 6272 (unsigned long) astContext.getSideTableAllocatedMemory()); 6273 6274 // How much memory is used for caching global code completion results? 6275 unsigned long completionBytes = 0; 6276 if (GlobalCodeCompletionAllocator *completionAllocator = 6277 astUnit->getCachedCompletionAllocator().getPtr()) { 6278 completionBytes = completionAllocator->getTotalMemory(); 6279 } 6280 createCXTUResourceUsageEntry(*entries, 6281 CXTUResourceUsage_GlobalCompletionResults, 6282 completionBytes); 6283 6284 // How much memory is being used by SourceManager's content cache? 6285 createCXTUResourceUsageEntry(*entries, 6286 CXTUResourceUsage_SourceManagerContentCache, 6287 (unsigned long) astContext.getSourceManager().getContentCacheSize()); 6288 6289 // How much memory is being used by the MemoryBuffer's in SourceManager? 6290 const SourceManager::MemoryBufferSizes &srcBufs = 6291 astUnit->getSourceManager().getMemoryBufferSizes(); 6292 6293 createCXTUResourceUsageEntry(*entries, 6294 CXTUResourceUsage_SourceManager_Membuffer_Malloc, 6295 (unsigned long) srcBufs.malloc_bytes); 6296 createCXTUResourceUsageEntry(*entries, 6297 CXTUResourceUsage_SourceManager_Membuffer_MMap, 6298 (unsigned long) srcBufs.mmap_bytes); 6299 createCXTUResourceUsageEntry(*entries, 6300 CXTUResourceUsage_SourceManager_DataStructures, 6301 (unsigned long) astContext.getSourceManager() 6302 .getDataStructureSizes()); 6303 6304 // How much memory is being used by the ExternalASTSource? 6305 if (ExternalASTSource *esrc = astContext.getExternalSource()) { 6306 const ExternalASTSource::MemoryBufferSizes &sizes = 6307 esrc->getMemoryBufferSizes(); 6308 6309 createCXTUResourceUsageEntry(*entries, 6310 CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc, 6311 (unsigned long) sizes.malloc_bytes); 6312 createCXTUResourceUsageEntry(*entries, 6313 CXTUResourceUsage_ExternalASTSource_Membuffer_MMap, 6314 (unsigned long) sizes.mmap_bytes); 6315 } 6316 6317 // How much memory is being used by the Preprocessor? 6318 Preprocessor &pp = astUnit->getPreprocessor(); 6319 createCXTUResourceUsageEntry(*entries, 6320 CXTUResourceUsage_Preprocessor, 6321 pp.getTotalMemory()); 6322 6323 if (PreprocessingRecord *pRec = pp.getPreprocessingRecord()) { 6324 createCXTUResourceUsageEntry(*entries, 6325 CXTUResourceUsage_PreprocessingRecord, 6326 pRec->getTotalMemory()); 6327 } 6328 6329 createCXTUResourceUsageEntry(*entries, 6330 CXTUResourceUsage_Preprocessor_HeaderSearch, 6331 pp.getHeaderSearchInfo().getTotalMemory()); 6332 6333 CXTUResourceUsage usage = { (void*) entries.get(), 6334 (unsigned) entries->size(), 6335 entries->size() ? &(*entries)[0] : 0 }; 6336 entries.take(); 6337 return usage; 6338} 6339 6340void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage) { 6341 if (usage.data) 6342 delete (MemUsageEntries*) usage.data; 6343} 6344 6345} // end extern "C" 6346 6347void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) { 6348 CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU); 6349 for (unsigned I = 0; I != Usage.numEntries; ++I) 6350 fprintf(stderr, " %s: %lu\n", 6351 clang_getTUResourceUsageName(Usage.entries[I].kind), 6352 Usage.entries[I].amount); 6353 6354 clang_disposeCXTUResourceUsage(Usage); 6355} 6356 6357//===----------------------------------------------------------------------===// 6358// Misc. utility functions. 6359//===----------------------------------------------------------------------===// 6360 6361/// Default to using an 8 MB stack size on "safety" threads. 6362static unsigned SafetyStackThreadSize = 8 << 20; 6363 6364namespace clang { 6365 6366bool RunSafely(llvm::CrashRecoveryContext &CRC, 6367 void (*Fn)(void*), void *UserData, 6368 unsigned Size) { 6369 if (!Size) 6370 Size = GetSafetyThreadStackSize(); 6371 if (Size) 6372 return CRC.RunSafelyOnThread(Fn, UserData, Size); 6373 return CRC.RunSafely(Fn, UserData); 6374} 6375 6376unsigned GetSafetyThreadStackSize() { 6377 return SafetyStackThreadSize; 6378} 6379 6380void SetSafetyThreadStackSize(unsigned Value) { 6381 SafetyStackThreadSize = Value; 6382} 6383 6384} 6385 6386void clang::setThreadBackgroundPriority() { 6387 if (getenv("LIBCLANG_BGPRIO_DISABLE")) 6388 return; 6389 6390 // FIXME: Move to llvm/Support and make it cross-platform. 6391#ifdef __APPLE__ 6392 setpriority(PRIO_DARWIN_THREAD, 0, PRIO_DARWIN_BG); 6393#endif 6394} 6395 6396void cxindex::printDiagsToStderr(ASTUnit *Unit) { 6397 if (!Unit) 6398 return; 6399 6400 for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(), 6401 DEnd = Unit->stored_diag_end(); 6402 D != DEnd; ++D) { 6403 CXStoredDiagnostic Diag(*D, Unit->getASTContext().getLangOpts()); 6404 CXString Msg = clang_formatDiagnostic(&Diag, 6405 clang_defaultDiagnosticDisplayOptions()); 6406 fprintf(stderr, "%s\n", clang_getCString(Msg)); 6407 clang_disposeString(Msg); 6408 } 6409#ifdef LLVM_ON_WIN32 6410 // On Windows, force a flush, since there may be multiple copies of 6411 // stderr and stdout in the file system, all with different buffers 6412 // but writing to the same device. 6413 fflush(stderr); 6414#endif 6415} 6416 6417MacroInfo *cxindex::getMacroInfo(const IdentifierInfo &II, 6418 SourceLocation MacroDefLoc, 6419 CXTranslationUnit TU){ 6420 if (MacroDefLoc.isInvalid() || !TU) 6421 return 0; 6422 if (!II.hadMacroDefinition()) 6423 return 0; 6424 6425 ASTUnit *Unit = cxtu::getASTUnit(TU); 6426 Preprocessor &PP = Unit->getPreprocessor(); 6427 MacroDirective *MD = PP.getMacroDirectiveHistory(&II); 6428 if (MD) { 6429 for (MacroDirective::DefInfo 6430 Def = MD->getDefinition(); Def; Def = Def.getPreviousDefinition()) { 6431 if (MacroDefLoc == Def.getMacroInfo()->getDefinitionLoc()) 6432 return Def.getMacroInfo(); 6433 } 6434 } 6435 6436 return 0; 6437} 6438 6439const MacroInfo *cxindex::getMacroInfo(const MacroDefinition *MacroDef, 6440 CXTranslationUnit TU) { 6441 if (!MacroDef || !TU) 6442 return 0; 6443 const IdentifierInfo *II = MacroDef->getName(); 6444 if (!II) 6445 return 0; 6446 6447 return getMacroInfo(*II, MacroDef->getLocation(), TU); 6448} 6449 6450MacroDefinition *cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, 6451 const Token &Tok, 6452 CXTranslationUnit TU) { 6453 if (!MI || !TU) 6454 return 0; 6455 if (Tok.isNot(tok::raw_identifier)) 6456 return 0; 6457 6458 if (MI->getNumTokens() == 0) 6459 return 0; 6460 SourceRange DefRange(MI->getReplacementToken(0).getLocation(), 6461 MI->getDefinitionEndLoc()); 6462 ASTUnit *Unit = cxtu::getASTUnit(TU); 6463 6464 // Check that the token is inside the definition and not its argument list. 6465 SourceManager &SM = Unit->getSourceManager(); 6466 if (SM.isBeforeInTranslationUnit(Tok.getLocation(), DefRange.getBegin())) 6467 return 0; 6468 if (SM.isBeforeInTranslationUnit(DefRange.getEnd(), Tok.getLocation())) 6469 return 0; 6470 6471 Preprocessor &PP = Unit->getPreprocessor(); 6472 PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); 6473 if (!PPRec) 6474 return 0; 6475 6476 StringRef Name(Tok.getRawIdentifierData(), Tok.getLength()); 6477 IdentifierInfo &II = PP.getIdentifierTable().get(Name); 6478 if (!II.hadMacroDefinition()) 6479 return 0; 6480 6481 // Check that the identifier is not one of the macro arguments. 6482 if (std::find(MI->arg_begin(), MI->arg_end(), &II) != MI->arg_end()) 6483 return 0; 6484 6485 MacroDirective *InnerMD = PP.getMacroDirectiveHistory(&II); 6486 if (!InnerMD) 6487 return 0; 6488 6489 return PPRec->findMacroDefinition(InnerMD->getMacroInfo()); 6490} 6491 6492MacroDefinition *cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, 6493 SourceLocation Loc, 6494 CXTranslationUnit TU) { 6495 if (Loc.isInvalid() || !MI || !TU) 6496 return 0; 6497 6498 if (MI->getNumTokens() == 0) 6499 return 0; 6500 ASTUnit *Unit = cxtu::getASTUnit(TU); 6501 Preprocessor &PP = Unit->getPreprocessor(); 6502 if (!PP.getPreprocessingRecord()) 6503 return 0; 6504 Loc = Unit->getSourceManager().getSpellingLoc(Loc); 6505 Token Tok; 6506 if (PP.getRawToken(Loc, Tok)) 6507 return 0; 6508 6509 return checkForMacroInMacroDefinition(MI, Tok, TU); 6510} 6511 6512extern "C" { 6513 6514CXString clang_getClangVersion() { 6515 return cxstring::createDup(getClangFullVersion()); 6516} 6517 6518} // end: extern "C" 6519 6520Logger &cxindex::Logger::operator<<(CXTranslationUnit TU) { 6521 if (TU) { 6522 if (ASTUnit *Unit = cxtu::getASTUnit(TU)) { 6523 LogOS << '<' << Unit->getMainFileName() << '>'; 6524 if (Unit->isMainFileAST()) 6525 LogOS << " (" << Unit->getASTFileName() << ')'; 6526 return *this; 6527 } 6528 } 6529 6530 LogOS << "<NULL TU>"; 6531 return *this; 6532} 6533 6534Logger &cxindex::Logger::operator<<(const FileEntry *FE) { 6535 *this << FE->getName(); 6536 return *this; 6537} 6538 6539Logger &cxindex::Logger::operator<<(CXCursor cursor) { 6540 CXString cursorName = clang_getCursorDisplayName(cursor); 6541 *this << cursorName << "@" << clang_getCursorLocation(cursor); 6542 clang_disposeString(cursorName); 6543 return *this; 6544} 6545 6546Logger &cxindex::Logger::operator<<(CXSourceLocation Loc) { 6547 CXFile File; 6548 unsigned Line, Column; 6549 clang_getFileLocation(Loc, &File, &Line, &Column, 0); 6550 CXString FileName = clang_getFileName(File); 6551 *this << llvm::format("(%s:%d:%d)", clang_getCString(FileName), Line, Column); 6552 clang_disposeString(FileName); 6553 return *this; 6554} 6555 6556Logger &cxindex::Logger::operator<<(CXSourceRange range) { 6557 CXSourceLocation BLoc = clang_getRangeStart(range); 6558 CXSourceLocation ELoc = clang_getRangeEnd(range); 6559 6560 CXFile BFile; 6561 unsigned BLine, BColumn; 6562 clang_getFileLocation(BLoc, &BFile, &BLine, &BColumn, 0); 6563 6564 CXFile EFile; 6565 unsigned ELine, EColumn; 6566 clang_getFileLocation(ELoc, &EFile, &ELine, &EColumn, 0); 6567 6568 CXString BFileName = clang_getFileName(BFile); 6569 if (BFile == EFile) { 6570 *this << llvm::format("[%s %d:%d-%d:%d]", clang_getCString(BFileName), 6571 BLine, BColumn, ELine, EColumn); 6572 } else { 6573 CXString EFileName = clang_getFileName(EFile); 6574 *this << llvm::format("[%s:%d:%d - ", clang_getCString(BFileName), 6575 BLine, BColumn) 6576 << llvm::format("%s:%d:%d]", clang_getCString(EFileName), 6577 ELine, EColumn); 6578 clang_disposeString(EFileName); 6579 } 6580 clang_disposeString(BFileName); 6581 return *this; 6582} 6583 6584Logger &cxindex::Logger::operator<<(CXString Str) { 6585 *this << clang_getCString(Str); 6586 return *this; 6587} 6588 6589Logger &cxindex::Logger::operator<<(const llvm::format_object_base &Fmt) { 6590 LogOS << Fmt; 6591 return *this; 6592} 6593 6594cxindex::Logger::~Logger() { 6595 LogOS.flush(); 6596 6597 llvm::sys::ScopedLock L(EnableMultithreadingMutex); 6598 6599 static llvm::TimeRecord sBeginTR = llvm::TimeRecord::getCurrentTime(); 6600 6601 raw_ostream &OS = llvm::errs(); 6602 OS << "[libclang:" << Name << ':'; 6603 6604 // FIXME: Portability. 6605#if HAVE_PTHREAD_H && __APPLE__ 6606 mach_port_t tid = pthread_mach_thread_np(pthread_self()); 6607 OS << tid << ':'; 6608#endif 6609 6610 llvm::TimeRecord TR = llvm::TimeRecord::getCurrentTime(); 6611 OS << llvm::format("%7.4f] ", TR.getWallTime() - sBeginTR.getWallTime()); 6612 OS << Msg.str() << '\n'; 6613 6614 if (Trace) { 6615 llvm::sys::PrintStackTrace(stderr); 6616 OS << "--------------------------------------------------\n"; 6617 } 6618} 6619