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 "CXCursor.h" 19#include "CXSourceLocation.h" 20#include "CXString.h" 21#include "CXTranslationUnit.h" 22#include "CXType.h" 23#include "CursorVisitor.h" 24#include "clang/AST/Attr.h" 25#include "clang/AST/Mangle.h" 26#include "clang/AST/StmtVisitor.h" 27#include "clang/Basic/Diagnostic.h" 28#include "clang/Basic/DiagnosticCategories.h" 29#include "clang/Basic/DiagnosticIDs.h" 30#include "clang/Basic/TargetInfo.h" 31#include "clang/Basic/Version.h" 32#include "clang/Frontend/ASTUnit.h" 33#include "clang/Frontend/CompilerInstance.h" 34#include "clang/Frontend/FrontendDiagnostic.h" 35#include "clang/Index/CommentToXML.h" 36#include "clang/Lex/HeaderSearch.h" 37#include "clang/Lex/Lexer.h" 38#include "clang/Lex/PreprocessingRecord.h" 39#include "clang/Lex/Preprocessor.h" 40#include "clang/Serialization/SerializationDiagnostic.h" 41#include "llvm/ADT/Optional.h" 42#include "llvm/ADT/STLExtras.h" 43#include "llvm/ADT/StringSwitch.h" 44#include "llvm/Config/llvm-config.h" 45#include "llvm/IR/DataLayout.h" 46#include "llvm/IR/Mangler.h" 47#include "llvm/Support/Compiler.h" 48#include "llvm/Support/CrashRecoveryContext.h" 49#include "llvm/Support/Format.h" 50#include "llvm/Support/ManagedStatic.h" 51#include "llvm/Support/MemoryBuffer.h" 52#include "llvm/Support/Mutex.h" 53#include "llvm/Support/Program.h" 54#include "llvm/Support/SaveAndRestore.h" 55#include "llvm/Support/Signals.h" 56#include "llvm/Support/TargetSelect.h" 57#include "llvm/Support/Threading.h" 58#include "llvm/Support/Timer.h" 59#include "llvm/Support/raw_ostream.h" 60 61#if LLVM_ENABLE_THREADS != 0 && defined(__APPLE__) 62#define USE_DARWIN_THREADS 63#endif 64 65#ifdef USE_DARWIN_THREADS 66#include <pthread.h> 67#endif 68 69using namespace clang; 70using namespace clang::cxcursor; 71using namespace clang::cxtu; 72using namespace clang::cxindex; 73 74CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx, ASTUnit *AU) { 75 if (!AU) 76 return nullptr; 77 assert(CIdx); 78 CXTranslationUnit D = new CXTranslationUnitImpl(); 79 D->CIdx = CIdx; 80 D->TheASTUnit = AU; 81 D->StringPool = new cxstring::CXStringPool(); 82 D->Diagnostics = nullptr; 83 D->OverridenCursorsPool = createOverridenCXCursorsPool(); 84 D->CommentToXML = nullptr; 85 return D; 86} 87 88bool cxtu::isASTReadError(ASTUnit *AU) { 89 for (ASTUnit::stored_diag_iterator D = AU->stored_diag_begin(), 90 DEnd = AU->stored_diag_end(); 91 D != DEnd; ++D) { 92 if (D->getLevel() >= DiagnosticsEngine::Error && 93 DiagnosticIDs::getCategoryNumberForDiag(D->getID()) == 94 diag::DiagCat_AST_Deserialization_Issue) 95 return true; 96 } 97 return false; 98} 99 100cxtu::CXTUOwner::~CXTUOwner() { 101 if (TU) 102 clang_disposeTranslationUnit(TU); 103} 104 105/// \brief Compare two source ranges to determine their relative position in 106/// the translation unit. 107static RangeComparisonResult RangeCompare(SourceManager &SM, 108 SourceRange R1, 109 SourceRange R2) { 110 assert(R1.isValid() && "First range is invalid?"); 111 assert(R2.isValid() && "Second range is invalid?"); 112 if (R1.getEnd() != R2.getBegin() && 113 SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin())) 114 return RangeBefore; 115 if (R2.getEnd() != R1.getBegin() && 116 SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin())) 117 return RangeAfter; 118 return RangeOverlap; 119} 120 121/// \brief Determine if a source location falls within, before, or after a 122/// a given source range. 123static RangeComparisonResult LocationCompare(SourceManager &SM, 124 SourceLocation L, SourceRange R) { 125 assert(R.isValid() && "First range is invalid?"); 126 assert(L.isValid() && "Second range is invalid?"); 127 if (L == R.getBegin() || L == R.getEnd()) 128 return RangeOverlap; 129 if (SM.isBeforeInTranslationUnit(L, R.getBegin())) 130 return RangeBefore; 131 if (SM.isBeforeInTranslationUnit(R.getEnd(), L)) 132 return RangeAfter; 133 return RangeOverlap; 134} 135 136/// \brief Translate a Clang source range into a CIndex source range. 137/// 138/// Clang internally represents ranges where the end location points to the 139/// start of the token at the end. However, for external clients it is more 140/// useful to have a CXSourceRange be a proper half-open interval. This routine 141/// does the appropriate translation. 142CXSourceRange cxloc::translateSourceRange(const SourceManager &SM, 143 const LangOptions &LangOpts, 144 const CharSourceRange &R) { 145 // We want the last character in this location, so we will adjust the 146 // location accordingly. 147 SourceLocation EndLoc = R.getEnd(); 148 if (EndLoc.isValid() && EndLoc.isMacroID() && !SM.isMacroArgExpansion(EndLoc)) 149 EndLoc = SM.getExpansionRange(EndLoc).second; 150 if (R.isTokenRange() && EndLoc.isValid()) { 151 unsigned Length = Lexer::MeasureTokenLength(SM.getSpellingLoc(EndLoc), 152 SM, LangOpts); 153 EndLoc = EndLoc.getLocWithOffset(Length); 154 } 155 156 CXSourceRange Result = { 157 { &SM, &LangOpts }, 158 R.getBegin().getRawEncoding(), 159 EndLoc.getRawEncoding() 160 }; 161 return Result; 162} 163 164//===----------------------------------------------------------------------===// 165// Cursor visitor. 166//===----------------------------------------------------------------------===// 167 168static SourceRange getRawCursorExtent(CXCursor C); 169static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr); 170 171 172RangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) { 173 return RangeCompare(AU->getSourceManager(), R, RegionOfInterest); 174} 175 176/// \brief Visit the given cursor and, if requested by the visitor, 177/// its children. 178/// 179/// \param Cursor the cursor to visit. 180/// 181/// \param CheckedRegionOfInterest if true, then the caller already checked 182/// that this cursor is within the region of interest. 183/// 184/// \returns true if the visitation should be aborted, false if it 185/// should continue. 186bool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) { 187 if (clang_isInvalid(Cursor.kind)) 188 return false; 189 190 if (clang_isDeclaration(Cursor.kind)) { 191 const Decl *D = getCursorDecl(Cursor); 192 if (!D) { 193 assert(0 && "Invalid declaration cursor"); 194 return true; // abort. 195 } 196 197 // Ignore implicit declarations, unless it's an objc method because 198 // currently we should report implicit methods for properties when indexing. 199 if (D->isImplicit() && !isa<ObjCMethodDecl>(D)) 200 return false; 201 } 202 203 // If we have a range of interest, and this cursor doesn't intersect with it, 204 // we're done. 205 if (RegionOfInterest.isValid() && !CheckedRegionOfInterest) { 206 SourceRange Range = getRawCursorExtent(Cursor); 207 if (Range.isInvalid() || CompareRegionOfInterest(Range)) 208 return false; 209 } 210 211 switch (Visitor(Cursor, Parent, ClientData)) { 212 case CXChildVisit_Break: 213 return true; 214 215 case CXChildVisit_Continue: 216 return false; 217 218 case CXChildVisit_Recurse: { 219 bool ret = VisitChildren(Cursor); 220 if (PostChildrenVisitor) 221 if (PostChildrenVisitor(Cursor, ClientData)) 222 return true; 223 return ret; 224 } 225 } 226 227 llvm_unreachable("Invalid CXChildVisitResult!"); 228} 229 230static bool visitPreprocessedEntitiesInRange(SourceRange R, 231 PreprocessingRecord &PPRec, 232 CursorVisitor &Visitor) { 233 SourceManager &SM = Visitor.getASTUnit()->getSourceManager(); 234 FileID FID; 235 236 if (!Visitor.shouldVisitIncludedEntities()) { 237 // If the begin/end of the range lie in the same FileID, do the optimization 238 // where we skip preprocessed entities that do not come from the same FileID. 239 FID = SM.getFileID(SM.getFileLoc(R.getBegin())); 240 if (FID != SM.getFileID(SM.getFileLoc(R.getEnd()))) 241 FID = FileID(); 242 } 243 244 const auto &Entities = PPRec.getPreprocessedEntitiesInRange(R); 245 return Visitor.visitPreprocessedEntities(Entities.begin(), Entities.end(), 246 PPRec, FID); 247} 248 249bool CursorVisitor::visitFileRegion() { 250 if (RegionOfInterest.isInvalid()) 251 return false; 252 253 ASTUnit *Unit = cxtu::getASTUnit(TU); 254 SourceManager &SM = Unit->getSourceManager(); 255 256 std::pair<FileID, unsigned> 257 Begin = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getBegin())), 258 End = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getEnd())); 259 260 if (End.first != Begin.first) { 261 // If the end does not reside in the same file, try to recover by 262 // picking the end of the file of begin location. 263 End.first = Begin.first; 264 End.second = SM.getFileIDSize(Begin.first); 265 } 266 267 assert(Begin.first == End.first); 268 if (Begin.second > End.second) 269 return false; 270 271 FileID File = Begin.first; 272 unsigned Offset = Begin.second; 273 unsigned Length = End.second - Begin.second; 274 275 if (!VisitDeclsOnly && !VisitPreprocessorLast) 276 if (visitPreprocessedEntitiesInRegion()) 277 return true; // visitation break. 278 279 if (visitDeclsFromFileRegion(File, Offset, Length)) 280 return true; // visitation break. 281 282 if (!VisitDeclsOnly && VisitPreprocessorLast) 283 return visitPreprocessedEntitiesInRegion(); 284 285 return false; 286} 287 288static bool isInLexicalContext(Decl *D, DeclContext *DC) { 289 if (!DC) 290 return false; 291 292 for (DeclContext *DeclDC = D->getLexicalDeclContext(); 293 DeclDC; DeclDC = DeclDC->getLexicalParent()) { 294 if (DeclDC == DC) 295 return true; 296 } 297 return false; 298} 299 300bool CursorVisitor::visitDeclsFromFileRegion(FileID File, 301 unsigned Offset, unsigned Length) { 302 ASTUnit *Unit = cxtu::getASTUnit(TU); 303 SourceManager &SM = Unit->getSourceManager(); 304 SourceRange Range = RegionOfInterest; 305 306 SmallVector<Decl *, 16> Decls; 307 Unit->findFileRegionDecls(File, Offset, Length, Decls); 308 309 // If we didn't find any file level decls for the file, try looking at the 310 // file that it was included from. 311 while (Decls.empty() || Decls.front()->isTopLevelDeclInObjCContainer()) { 312 bool Invalid = false; 313 const SrcMgr::SLocEntry &SLEntry = SM.getSLocEntry(File, &Invalid); 314 if (Invalid) 315 return false; 316 317 SourceLocation Outer; 318 if (SLEntry.isFile()) 319 Outer = SLEntry.getFile().getIncludeLoc(); 320 else 321 Outer = SLEntry.getExpansion().getExpansionLocStart(); 322 if (Outer.isInvalid()) 323 return false; 324 325 std::tie(File, Offset) = SM.getDecomposedExpansionLoc(Outer); 326 Length = 0; 327 Unit->findFileRegionDecls(File, Offset, Length, Decls); 328 } 329 330 assert(!Decls.empty()); 331 332 bool VisitedAtLeastOnce = false; 333 DeclContext *CurDC = nullptr; 334 SmallVectorImpl<Decl *>::iterator DIt = Decls.begin(); 335 for (SmallVectorImpl<Decl *>::iterator DE = Decls.end(); DIt != DE; ++DIt) { 336 Decl *D = *DIt; 337 if (D->getSourceRange().isInvalid()) 338 continue; 339 340 if (isInLexicalContext(D, CurDC)) 341 continue; 342 343 CurDC = dyn_cast<DeclContext>(D); 344 345 if (TagDecl *TD = dyn_cast<TagDecl>(D)) 346 if (!TD->isFreeStanding()) 347 continue; 348 349 RangeComparisonResult CompRes = RangeCompare(SM, D->getSourceRange(),Range); 350 if (CompRes == RangeBefore) 351 continue; 352 if (CompRes == RangeAfter) 353 break; 354 355 assert(CompRes == RangeOverlap); 356 VisitedAtLeastOnce = true; 357 358 if (isa<ObjCContainerDecl>(D)) { 359 FileDI_current = &DIt; 360 FileDE_current = DE; 361 } else { 362 FileDI_current = nullptr; 363 } 364 365 if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true)) 366 return true; // visitation break. 367 } 368 369 if (VisitedAtLeastOnce) 370 return false; 371 372 // No Decls overlapped with the range. Move up the lexical context until there 373 // is a context that contains the range or we reach the translation unit 374 // level. 375 DeclContext *DC = DIt == Decls.begin() ? (*DIt)->getLexicalDeclContext() 376 : (*(DIt-1))->getLexicalDeclContext(); 377 378 while (DC && !DC->isTranslationUnit()) { 379 Decl *D = cast<Decl>(DC); 380 SourceRange CurDeclRange = D->getSourceRange(); 381 if (CurDeclRange.isInvalid()) 382 break; 383 384 if (RangeCompare(SM, CurDeclRange, Range) == RangeOverlap) { 385 if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true)) 386 return true; // visitation break. 387 } 388 389 DC = D->getLexicalDeclContext(); 390 } 391 392 return false; 393} 394 395bool CursorVisitor::visitPreprocessedEntitiesInRegion() { 396 if (!AU->getPreprocessor().getPreprocessingRecord()) 397 return false; 398 399 PreprocessingRecord &PPRec 400 = *AU->getPreprocessor().getPreprocessingRecord(); 401 SourceManager &SM = AU->getSourceManager(); 402 403 if (RegionOfInterest.isValid()) { 404 SourceRange MappedRange = AU->mapRangeToPreamble(RegionOfInterest); 405 SourceLocation B = MappedRange.getBegin(); 406 SourceLocation E = MappedRange.getEnd(); 407 408 if (AU->isInPreambleFileID(B)) { 409 if (SM.isLoadedSourceLocation(E)) 410 return visitPreprocessedEntitiesInRange(SourceRange(B, E), 411 PPRec, *this); 412 413 // Beginning of range lies in the preamble but it also extends beyond 414 // it into the main file. Split the range into 2 parts, one covering 415 // the preamble and another covering the main file. This allows subsequent 416 // calls to visitPreprocessedEntitiesInRange to accept a source range that 417 // lies in the same FileID, allowing it to skip preprocessed entities that 418 // do not come from the same FileID. 419 bool breaked = 420 visitPreprocessedEntitiesInRange( 421 SourceRange(B, AU->getEndOfPreambleFileID()), 422 PPRec, *this); 423 if (breaked) return true; 424 return visitPreprocessedEntitiesInRange( 425 SourceRange(AU->getStartOfMainFileID(), E), 426 PPRec, *this); 427 } 428 429 return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec, *this); 430 } 431 432 bool OnlyLocalDecls 433 = !AU->isMainFileAST() && AU->getOnlyLocalDecls(); 434 435 if (OnlyLocalDecls) 436 return visitPreprocessedEntities(PPRec.local_begin(), PPRec.local_end(), 437 PPRec); 438 439 return visitPreprocessedEntities(PPRec.begin(), PPRec.end(), PPRec); 440} 441 442template<typename InputIterator> 443bool CursorVisitor::visitPreprocessedEntities(InputIterator First, 444 InputIterator Last, 445 PreprocessingRecord &PPRec, 446 FileID FID) { 447 for (; First != Last; ++First) { 448 if (!FID.isInvalid() && !PPRec.isEntityInFileID(First, FID)) 449 continue; 450 451 PreprocessedEntity *PPE = *First; 452 if (!PPE) 453 continue; 454 455 if (MacroExpansion *ME = dyn_cast<MacroExpansion>(PPE)) { 456 if (Visit(MakeMacroExpansionCursor(ME, TU))) 457 return true; 458 459 continue; 460 } 461 462 if (MacroDefinitionRecord *MD = dyn_cast<MacroDefinitionRecord>(PPE)) { 463 if (Visit(MakeMacroDefinitionCursor(MD, TU))) 464 return true; 465 466 continue; 467 } 468 469 if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) { 470 if (Visit(MakeInclusionDirectiveCursor(ID, TU))) 471 return true; 472 473 continue; 474 } 475 } 476 477 return false; 478} 479 480/// \brief Visit the children of the given cursor. 481/// 482/// \returns true if the visitation should be aborted, false if it 483/// should continue. 484bool CursorVisitor::VisitChildren(CXCursor Cursor) { 485 if (clang_isReference(Cursor.kind) && 486 Cursor.kind != CXCursor_CXXBaseSpecifier) { 487 // By definition, references have no children. 488 return false; 489 } 490 491 // Set the Parent field to Cursor, then back to its old value once we're 492 // done. 493 SetParentRAII SetParent(Parent, StmtParent, Cursor); 494 495 if (clang_isDeclaration(Cursor.kind)) { 496 Decl *D = const_cast<Decl *>(getCursorDecl(Cursor)); 497 if (!D) 498 return false; 499 500 return VisitAttributes(D) || Visit(D); 501 } 502 503 if (clang_isStatement(Cursor.kind)) { 504 if (const Stmt *S = getCursorStmt(Cursor)) 505 return Visit(S); 506 507 return false; 508 } 509 510 if (clang_isExpression(Cursor.kind)) { 511 if (const Expr *E = getCursorExpr(Cursor)) 512 return Visit(E); 513 514 return false; 515 } 516 517 if (clang_isTranslationUnit(Cursor.kind)) { 518 CXTranslationUnit TU = getCursorTU(Cursor); 519 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 520 521 int VisitOrder[2] = { VisitPreprocessorLast, !VisitPreprocessorLast }; 522 for (unsigned I = 0; I != 2; ++I) { 523 if (VisitOrder[I]) { 524 if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() && 525 RegionOfInterest.isInvalid()) { 526 for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(), 527 TLEnd = CXXUnit->top_level_end(); 528 TL != TLEnd; ++TL) { 529 if (Visit(MakeCXCursor(*TL, TU, RegionOfInterest), true)) 530 return true; 531 } 532 } else if (VisitDeclContext( 533 CXXUnit->getASTContext().getTranslationUnitDecl())) 534 return true; 535 continue; 536 } 537 538 // Walk the preprocessing record. 539 if (CXXUnit->getPreprocessor().getPreprocessingRecord()) 540 visitPreprocessedEntitiesInRegion(); 541 } 542 543 return false; 544 } 545 546 if (Cursor.kind == CXCursor_CXXBaseSpecifier) { 547 if (const CXXBaseSpecifier *Base = getCursorCXXBaseSpecifier(Cursor)) { 548 if (TypeSourceInfo *BaseTSInfo = Base->getTypeSourceInfo()) { 549 return Visit(BaseTSInfo->getTypeLoc()); 550 } 551 } 552 } 553 554 if (Cursor.kind == CXCursor_IBOutletCollectionAttr) { 555 const IBOutletCollectionAttr *A = 556 cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(Cursor)); 557 if (const ObjCObjectType *ObjT = A->getInterface()->getAs<ObjCObjectType>()) 558 return Visit(cxcursor::MakeCursorObjCClassRef( 559 ObjT->getInterface(), 560 A->getInterfaceLoc()->getTypeLoc().getLocStart(), TU)); 561 } 562 563 // If pointing inside a macro definition, check if the token is an identifier 564 // that was ever defined as a macro. In such a case, create a "pseudo" macro 565 // expansion cursor for that token. 566 SourceLocation BeginLoc = RegionOfInterest.getBegin(); 567 if (Cursor.kind == CXCursor_MacroDefinition && 568 BeginLoc == RegionOfInterest.getEnd()) { 569 SourceLocation Loc = AU->mapLocationToPreamble(BeginLoc); 570 const MacroInfo *MI = 571 getMacroInfo(cxcursor::getCursorMacroDefinition(Cursor), TU); 572 if (MacroDefinitionRecord *MacroDef = 573 checkForMacroInMacroDefinition(MI, Loc, TU)) 574 return Visit(cxcursor::MakeMacroExpansionCursor(MacroDef, BeginLoc, TU)); 575 } 576 577 // Nothing to visit at the moment. 578 return false; 579} 580 581bool CursorVisitor::VisitBlockDecl(BlockDecl *B) { 582 if (TypeSourceInfo *TSInfo = B->getSignatureAsWritten()) 583 if (Visit(TSInfo->getTypeLoc())) 584 return true; 585 586 if (Stmt *Body = B->getBody()) 587 return Visit(MakeCXCursor(Body, StmtParent, TU, RegionOfInterest)); 588 589 return false; 590} 591 592Optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) { 593 if (RegionOfInterest.isValid()) { 594 SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager()); 595 if (Range.isInvalid()) 596 return None; 597 598 switch (CompareRegionOfInterest(Range)) { 599 case RangeBefore: 600 // This declaration comes before the region of interest; skip it. 601 return None; 602 603 case RangeAfter: 604 // This declaration comes after the region of interest; we're done. 605 return false; 606 607 case RangeOverlap: 608 // This declaration overlaps the region of interest; visit it. 609 break; 610 } 611 } 612 return true; 613} 614 615bool CursorVisitor::VisitDeclContext(DeclContext *DC) { 616 DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end(); 617 618 // FIXME: Eventually remove. This part of a hack to support proper 619 // iteration over all Decls contained lexically within an ObjC container. 620 SaveAndRestore<DeclContext::decl_iterator*> DI_saved(DI_current, &I); 621 SaveAndRestore<DeclContext::decl_iterator> DE_saved(DE_current, E); 622 623 for ( ; I != E; ++I) { 624 Decl *D = *I; 625 if (D->getLexicalDeclContext() != DC) 626 continue; 627 CXCursor Cursor = MakeCXCursor(D, TU, RegionOfInterest); 628 629 // Ignore synthesized ivars here, otherwise if we have something like: 630 // @synthesize prop = _prop; 631 // and '_prop' is not declared, we will encounter a '_prop' ivar before 632 // encountering the 'prop' synthesize declaration and we will think that 633 // we passed the region-of-interest. 634 if (ObjCIvarDecl *ivarD = dyn_cast<ObjCIvarDecl>(D)) { 635 if (ivarD->getSynthesize()) 636 continue; 637 } 638 639 // FIXME: ObjCClassRef/ObjCProtocolRef for forward class/protocol 640 // declarations is a mismatch with the compiler semantics. 641 if (Cursor.kind == CXCursor_ObjCInterfaceDecl) { 642 ObjCInterfaceDecl *ID = cast<ObjCInterfaceDecl>(D); 643 if (!ID->isThisDeclarationADefinition()) 644 Cursor = MakeCursorObjCClassRef(ID, ID->getLocation(), TU); 645 646 } else if (Cursor.kind == CXCursor_ObjCProtocolDecl) { 647 ObjCProtocolDecl *PD = cast<ObjCProtocolDecl>(D); 648 if (!PD->isThisDeclarationADefinition()) 649 Cursor = MakeCursorObjCProtocolRef(PD, PD->getLocation(), TU); 650 } 651 652 const Optional<bool> &V = shouldVisitCursor(Cursor); 653 if (!V.hasValue()) 654 continue; 655 if (!V.getValue()) 656 return false; 657 if (Visit(Cursor, true)) 658 return true; 659 } 660 return false; 661} 662 663bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 664 llvm_unreachable("Translation units are visited directly by Visit()"); 665} 666 667bool CursorVisitor::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { 668 if (VisitTemplateParameters(D->getTemplateParameters())) 669 return true; 670 671 return Visit(MakeCXCursor(D->getTemplatedDecl(), TU, RegionOfInterest)); 672} 673 674bool CursorVisitor::VisitTypeAliasDecl(TypeAliasDecl *D) { 675 if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo()) 676 return Visit(TSInfo->getTypeLoc()); 677 678 return false; 679} 680 681bool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) { 682 if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo()) 683 return Visit(TSInfo->getTypeLoc()); 684 685 return false; 686} 687 688bool CursorVisitor::VisitTagDecl(TagDecl *D) { 689 return VisitDeclContext(D); 690} 691 692bool CursorVisitor::VisitClassTemplateSpecializationDecl( 693 ClassTemplateSpecializationDecl *D) { 694 bool ShouldVisitBody = false; 695 switch (D->getSpecializationKind()) { 696 case TSK_Undeclared: 697 case TSK_ImplicitInstantiation: 698 // Nothing to visit 699 return false; 700 701 case TSK_ExplicitInstantiationDeclaration: 702 case TSK_ExplicitInstantiationDefinition: 703 break; 704 705 case TSK_ExplicitSpecialization: 706 ShouldVisitBody = true; 707 break; 708 } 709 710 // Visit the template arguments used in the specialization. 711 if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) { 712 TypeLoc TL = SpecType->getTypeLoc(); 713 if (TemplateSpecializationTypeLoc TSTLoc = 714 TL.getAs<TemplateSpecializationTypeLoc>()) { 715 for (unsigned I = 0, N = TSTLoc.getNumArgs(); I != N; ++I) 716 if (VisitTemplateArgumentLoc(TSTLoc.getArgLoc(I))) 717 return true; 718 } 719 } 720 721 if (ShouldVisitBody && VisitCXXRecordDecl(D)) 722 return true; 723 724 return false; 725} 726 727bool CursorVisitor::VisitClassTemplatePartialSpecializationDecl( 728 ClassTemplatePartialSpecializationDecl *D) { 729 // FIXME: Visit the "outer" template parameter lists on the TagDecl 730 // before visiting these template parameters. 731 if (VisitTemplateParameters(D->getTemplateParameters())) 732 return true; 733 734 // Visit the partial specialization arguments. 735 const ASTTemplateArgumentListInfo *Info = D->getTemplateArgsAsWritten(); 736 const TemplateArgumentLoc *TemplateArgs = Info->getTemplateArgs(); 737 for (unsigned I = 0, N = Info->NumTemplateArgs; I != N; ++I) 738 if (VisitTemplateArgumentLoc(TemplateArgs[I])) 739 return true; 740 741 return VisitCXXRecordDecl(D); 742} 743 744bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 745 // Visit the default argument. 746 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 747 if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo()) 748 if (Visit(DefArg->getTypeLoc())) 749 return true; 750 751 return false; 752} 753 754bool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) { 755 if (Expr *Init = D->getInitExpr()) 756 return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest)); 757 return false; 758} 759 760bool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) { 761 unsigned NumParamList = DD->getNumTemplateParameterLists(); 762 for (unsigned i = 0; i < NumParamList; i++) { 763 TemplateParameterList* Params = DD->getTemplateParameterList(i); 764 if (VisitTemplateParameters(Params)) 765 return true; 766 } 767 768 if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo()) 769 if (Visit(TSInfo->getTypeLoc())) 770 return true; 771 772 // Visit the nested-name-specifier, if present. 773 if (NestedNameSpecifierLoc QualifierLoc = DD->getQualifierLoc()) 774 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 775 return true; 776 777 return false; 778} 779 780/// \brief Compare two base or member initializers based on their source order. 781static int CompareCXXCtorInitializers(CXXCtorInitializer *const *X, 782 CXXCtorInitializer *const *Y) { 783 return (*X)->getSourceOrder() - (*Y)->getSourceOrder(); 784} 785 786bool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) { 787 unsigned NumParamList = ND->getNumTemplateParameterLists(); 788 for (unsigned i = 0; i < NumParamList; i++) { 789 TemplateParameterList* Params = ND->getTemplateParameterList(i); 790 if (VisitTemplateParameters(Params)) 791 return true; 792 } 793 794 if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) { 795 // Visit the function declaration's syntactic components in the order 796 // written. This requires a bit of work. 797 TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens(); 798 FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>(); 799 800 // If we have a function declared directly (without the use of a typedef), 801 // visit just the return type. Otherwise, just visit the function's type 802 // now. 803 if ((FTL && !isa<CXXConversionDecl>(ND) && Visit(FTL.getReturnLoc())) || 804 (!FTL && Visit(TL))) 805 return true; 806 807 // Visit the nested-name-specifier, if present. 808 if (NestedNameSpecifierLoc QualifierLoc = ND->getQualifierLoc()) 809 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 810 return true; 811 812 // Visit the declaration name. 813 if (!isa<CXXDestructorDecl>(ND)) 814 if (VisitDeclarationNameInfo(ND->getNameInfo())) 815 return true; 816 817 // FIXME: Visit explicitly-specified template arguments! 818 819 // Visit the function parameters, if we have a function type. 820 if (FTL && VisitFunctionTypeLoc(FTL, true)) 821 return true; 822 823 // FIXME: Attributes? 824 } 825 826 if (ND->doesThisDeclarationHaveABody() && !ND->isLateTemplateParsed()) { 827 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) { 828 // Find the initializers that were written in the source. 829 SmallVector<CXXCtorInitializer *, 4> WrittenInits; 830 for (auto *I : Constructor->inits()) { 831 if (!I->isWritten()) 832 continue; 833 834 WrittenInits.push_back(I); 835 } 836 837 // Sort the initializers in source order 838 llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(), 839 &CompareCXXCtorInitializers); 840 841 // Visit the initializers in source order 842 for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) { 843 CXXCtorInitializer *Init = WrittenInits[I]; 844 if (Init->isAnyMemberInitializer()) { 845 if (Visit(MakeCursorMemberRef(Init->getAnyMember(), 846 Init->getMemberLocation(), TU))) 847 return true; 848 } else if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) { 849 if (Visit(TInfo->getTypeLoc())) 850 return true; 851 } 852 853 // Visit the initializer value. 854 if (Expr *Initializer = Init->getInit()) 855 if (Visit(MakeCXCursor(Initializer, ND, TU, RegionOfInterest))) 856 return true; 857 } 858 } 859 860 if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest))) 861 return true; 862 } 863 864 return false; 865} 866 867bool CursorVisitor::VisitFieldDecl(FieldDecl *D) { 868 if (VisitDeclaratorDecl(D)) 869 return true; 870 871 if (Expr *BitWidth = D->getBitWidth()) 872 return Visit(MakeCXCursor(BitWidth, StmtParent, TU, RegionOfInterest)); 873 874 return false; 875} 876 877bool CursorVisitor::VisitVarDecl(VarDecl *D) { 878 if (VisitDeclaratorDecl(D)) 879 return true; 880 881 if (Expr *Init = D->getInit()) 882 return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest)); 883 884 return false; 885} 886 887bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 888 if (VisitDeclaratorDecl(D)) 889 return true; 890 891 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 892 if (Expr *DefArg = D->getDefaultArgument()) 893 return Visit(MakeCXCursor(DefArg, StmtParent, TU, RegionOfInterest)); 894 895 return false; 896} 897 898bool CursorVisitor::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 899 // FIXME: Visit the "outer" template parameter lists on the FunctionDecl 900 // before visiting these template parameters. 901 if (VisitTemplateParameters(D->getTemplateParameters())) 902 return true; 903 904 return VisitFunctionDecl(D->getTemplatedDecl()); 905} 906 907bool CursorVisitor::VisitClassTemplateDecl(ClassTemplateDecl *D) { 908 // FIXME: Visit the "outer" template parameter lists on the TagDecl 909 // before visiting these template parameters. 910 if (VisitTemplateParameters(D->getTemplateParameters())) 911 return true; 912 913 return VisitCXXRecordDecl(D->getTemplatedDecl()); 914} 915 916bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 917 if (VisitTemplateParameters(D->getTemplateParameters())) 918 return true; 919 920 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() && 921 VisitTemplateArgumentLoc(D->getDefaultArgument())) 922 return true; 923 924 return false; 925} 926 927bool CursorVisitor::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) { 928 // Visit the bound, if it's explicit. 929 if (D->hasExplicitBound()) { 930 if (auto TInfo = D->getTypeSourceInfo()) { 931 if (Visit(TInfo->getTypeLoc())) 932 return true; 933 } 934 } 935 936 return false; 937} 938 939bool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) { 940 if (TypeSourceInfo *TSInfo = ND->getReturnTypeSourceInfo()) 941 if (Visit(TSInfo->getTypeLoc())) 942 return true; 943 944 for (const auto *P : ND->params()) { 945 if (Visit(MakeCXCursor(P, TU, RegionOfInterest))) 946 return true; 947 } 948 949 if (ND->isThisDeclarationADefinition() && 950 Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest))) 951 return true; 952 953 return false; 954} 955 956template <typename DeclIt> 957static void addRangedDeclsInContainer(DeclIt *DI_current, DeclIt DE_current, 958 SourceManager &SM, SourceLocation EndLoc, 959 SmallVectorImpl<Decl *> &Decls) { 960 DeclIt next = *DI_current; 961 while (++next != DE_current) { 962 Decl *D_next = *next; 963 if (!D_next) 964 break; 965 SourceLocation L = D_next->getLocStart(); 966 if (!L.isValid()) 967 break; 968 if (SM.isBeforeInTranslationUnit(L, EndLoc)) { 969 *DI_current = next; 970 Decls.push_back(D_next); 971 continue; 972 } 973 break; 974 } 975} 976 977bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) { 978 // FIXME: Eventually convert back to just 'VisitDeclContext()'. Essentially 979 // an @implementation can lexically contain Decls that are not properly 980 // nested in the AST. When we identify such cases, we need to retrofit 981 // this nesting here. 982 if (!DI_current && !FileDI_current) 983 return VisitDeclContext(D); 984 985 // Scan the Decls that immediately come after the container 986 // in the current DeclContext. If any fall within the 987 // container's lexical region, stash them into a vector 988 // for later processing. 989 SmallVector<Decl *, 24> DeclsInContainer; 990 SourceLocation EndLoc = D->getSourceRange().getEnd(); 991 SourceManager &SM = AU->getSourceManager(); 992 if (EndLoc.isValid()) { 993 if (DI_current) { 994 addRangedDeclsInContainer(DI_current, DE_current, SM, EndLoc, 995 DeclsInContainer); 996 } else { 997 addRangedDeclsInContainer(FileDI_current, FileDE_current, SM, EndLoc, 998 DeclsInContainer); 999 } 1000 } 1001 1002 // The common case. 1003 if (DeclsInContainer.empty()) 1004 return VisitDeclContext(D); 1005 1006 // Get all the Decls in the DeclContext, and sort them with the 1007 // additional ones we've collected. Then visit them. 1008 for (auto *SubDecl : D->decls()) { 1009 if (!SubDecl || SubDecl->getLexicalDeclContext() != D || 1010 SubDecl->getLocStart().isInvalid()) 1011 continue; 1012 DeclsInContainer.push_back(SubDecl); 1013 } 1014 1015 // Now sort the Decls so that they appear in lexical order. 1016 std::sort(DeclsInContainer.begin(), DeclsInContainer.end(), 1017 [&SM](Decl *A, Decl *B) { 1018 SourceLocation L_A = A->getLocStart(); 1019 SourceLocation L_B = B->getLocStart(); 1020 assert(L_A.isValid() && L_B.isValid()); 1021 return SM.isBeforeInTranslationUnit(L_A, L_B); 1022 }); 1023 1024 // Now visit the decls. 1025 for (SmallVectorImpl<Decl*>::iterator I = DeclsInContainer.begin(), 1026 E = DeclsInContainer.end(); I != E; ++I) { 1027 CXCursor Cursor = MakeCXCursor(*I, TU, RegionOfInterest); 1028 const Optional<bool> &V = shouldVisitCursor(Cursor); 1029 if (!V.hasValue()) 1030 continue; 1031 if (!V.getValue()) 1032 return false; 1033 if (Visit(Cursor, true)) 1034 return true; 1035 } 1036 return false; 1037} 1038 1039bool CursorVisitor::VisitObjCCategoryDecl(ObjCCategoryDecl *ND) { 1040 if (Visit(MakeCursorObjCClassRef(ND->getClassInterface(), ND->getLocation(), 1041 TU))) 1042 return true; 1043 1044 if (VisitObjCTypeParamList(ND->getTypeParamList())) 1045 return true; 1046 1047 ObjCCategoryDecl::protocol_loc_iterator PL = ND->protocol_loc_begin(); 1048 for (ObjCCategoryDecl::protocol_iterator I = ND->protocol_begin(), 1049 E = ND->protocol_end(); I != E; ++I, ++PL) 1050 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1051 return true; 1052 1053 return VisitObjCContainerDecl(ND); 1054} 1055 1056bool CursorVisitor::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) { 1057 if (!PID->isThisDeclarationADefinition()) 1058 return Visit(MakeCursorObjCProtocolRef(PID, PID->getLocation(), TU)); 1059 1060 ObjCProtocolDecl::protocol_loc_iterator PL = PID->protocol_loc_begin(); 1061 for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(), 1062 E = PID->protocol_end(); I != E; ++I, ++PL) 1063 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1064 return true; 1065 1066 return VisitObjCContainerDecl(PID); 1067} 1068 1069bool CursorVisitor::VisitObjCPropertyDecl(ObjCPropertyDecl *PD) { 1070 if (PD->getTypeSourceInfo() && Visit(PD->getTypeSourceInfo()->getTypeLoc())) 1071 return true; 1072 1073 // FIXME: This implements a workaround with @property declarations also being 1074 // installed in the DeclContext for the @interface. Eventually this code 1075 // should be removed. 1076 ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(PD->getDeclContext()); 1077 if (!CDecl || !CDecl->IsClassExtension()) 1078 return false; 1079 1080 ObjCInterfaceDecl *ID = CDecl->getClassInterface(); 1081 if (!ID) 1082 return false; 1083 1084 IdentifierInfo *PropertyId = PD->getIdentifier(); 1085 ObjCPropertyDecl *prevDecl = 1086 ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(ID), PropertyId); 1087 1088 if (!prevDecl) 1089 return false; 1090 1091 // Visit synthesized methods since they will be skipped when visiting 1092 // the @interface. 1093 if (ObjCMethodDecl *MD = prevDecl->getGetterMethodDecl()) 1094 if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl) 1095 if (Visit(MakeCXCursor(MD, TU, RegionOfInterest))) 1096 return true; 1097 1098 if (ObjCMethodDecl *MD = prevDecl->getSetterMethodDecl()) 1099 if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl) 1100 if (Visit(MakeCXCursor(MD, TU, RegionOfInterest))) 1101 return true; 1102 1103 return false; 1104} 1105 1106bool CursorVisitor::VisitObjCTypeParamList(ObjCTypeParamList *typeParamList) { 1107 if (!typeParamList) 1108 return false; 1109 1110 for (auto *typeParam : *typeParamList) { 1111 // Visit the type parameter. 1112 if (Visit(MakeCXCursor(typeParam, TU, RegionOfInterest))) 1113 return true; 1114 } 1115 1116 return false; 1117} 1118 1119bool CursorVisitor::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 1120 if (!D->isThisDeclarationADefinition()) { 1121 // Forward declaration is treated like a reference. 1122 return Visit(MakeCursorObjCClassRef(D, D->getLocation(), TU)); 1123 } 1124 1125 // Objective-C type parameters. 1126 if (VisitObjCTypeParamList(D->getTypeParamListAsWritten())) 1127 return true; 1128 1129 // Issue callbacks for super class. 1130 if (D->getSuperClass() && 1131 Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(), 1132 D->getSuperClassLoc(), 1133 TU))) 1134 return true; 1135 1136 if (TypeSourceInfo *SuperClassTInfo = D->getSuperClassTInfo()) 1137 if (Visit(SuperClassTInfo->getTypeLoc())) 1138 return true; 1139 1140 ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(); 1141 for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(), 1142 E = D->protocol_end(); I != E; ++I, ++PL) 1143 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1144 return true; 1145 1146 return VisitObjCContainerDecl(D); 1147} 1148 1149bool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) { 1150 return VisitObjCContainerDecl(D); 1151} 1152 1153bool CursorVisitor::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 1154 // 'ID' could be null when dealing with invalid code. 1155 if (ObjCInterfaceDecl *ID = D->getClassInterface()) 1156 if (Visit(MakeCursorObjCClassRef(ID, D->getLocation(), TU))) 1157 return true; 1158 1159 return VisitObjCImplDecl(D); 1160} 1161 1162bool CursorVisitor::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 1163#if 0 1164 // Issue callbacks for super class. 1165 // FIXME: No source location information! 1166 if (D->getSuperClass() && 1167 Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(), 1168 D->getSuperClassLoc(), 1169 TU))) 1170 return true; 1171#endif 1172 1173 return VisitObjCImplDecl(D); 1174} 1175 1176bool CursorVisitor::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD) { 1177 if (ObjCIvarDecl *Ivar = PD->getPropertyIvarDecl()) 1178 if (PD->isIvarNameSpecified()) 1179 return Visit(MakeCursorMemberRef(Ivar, PD->getPropertyIvarDeclLoc(), TU)); 1180 1181 return false; 1182} 1183 1184bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) { 1185 return VisitDeclContext(D); 1186} 1187 1188bool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 1189 // Visit nested-name-specifier. 1190 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1191 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1192 return true; 1193 1194 return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(), 1195 D->getTargetNameLoc(), TU)); 1196} 1197 1198bool CursorVisitor::VisitUsingDecl(UsingDecl *D) { 1199 // Visit nested-name-specifier. 1200 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) { 1201 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1202 return true; 1203 } 1204 1205 if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU))) 1206 return true; 1207 1208 return VisitDeclarationNameInfo(D->getNameInfo()); 1209} 1210 1211bool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 1212 // Visit nested-name-specifier. 1213 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1214 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1215 return true; 1216 1217 return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(), 1218 D->getIdentLocation(), TU)); 1219} 1220 1221bool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 1222 // Visit nested-name-specifier. 1223 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) { 1224 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1225 return true; 1226 } 1227 1228 return VisitDeclarationNameInfo(D->getNameInfo()); 1229} 1230 1231bool CursorVisitor::VisitUnresolvedUsingTypenameDecl( 1232 UnresolvedUsingTypenameDecl *D) { 1233 // Visit nested-name-specifier. 1234 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1235 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1236 return true; 1237 1238 return false; 1239} 1240 1241bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) { 1242 switch (Name.getName().getNameKind()) { 1243 case clang::DeclarationName::Identifier: 1244 case clang::DeclarationName::CXXLiteralOperatorName: 1245 case clang::DeclarationName::CXXOperatorName: 1246 case clang::DeclarationName::CXXUsingDirective: 1247 return false; 1248 1249 case clang::DeclarationName::CXXConstructorName: 1250 case clang::DeclarationName::CXXDestructorName: 1251 case clang::DeclarationName::CXXConversionFunctionName: 1252 if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo()) 1253 return Visit(TSInfo->getTypeLoc()); 1254 return false; 1255 1256 case clang::DeclarationName::ObjCZeroArgSelector: 1257 case clang::DeclarationName::ObjCOneArgSelector: 1258 case clang::DeclarationName::ObjCMultiArgSelector: 1259 // FIXME: Per-identifier location info? 1260 return false; 1261 } 1262 1263 llvm_unreachable("Invalid DeclarationName::Kind!"); 1264} 1265 1266bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS, 1267 SourceRange Range) { 1268 // FIXME: This whole routine is a hack to work around the lack of proper 1269 // source information in nested-name-specifiers (PR5791). Since we do have 1270 // a beginning source location, we can visit the first component of the 1271 // nested-name-specifier, if it's a single-token component. 1272 if (!NNS) 1273 return false; 1274 1275 // Get the first component in the nested-name-specifier. 1276 while (NestedNameSpecifier *Prefix = NNS->getPrefix()) 1277 NNS = Prefix; 1278 1279 switch (NNS->getKind()) { 1280 case NestedNameSpecifier::Namespace: 1281 return Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(), 1282 TU)); 1283 1284 case NestedNameSpecifier::NamespaceAlias: 1285 return Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 1286 Range.getBegin(), TU)); 1287 1288 case NestedNameSpecifier::TypeSpec: { 1289 // If the type has a form where we know that the beginning of the source 1290 // range matches up with a reference cursor. Visit the appropriate reference 1291 // cursor. 1292 const Type *T = NNS->getAsType(); 1293 if (const TypedefType *Typedef = dyn_cast<TypedefType>(T)) 1294 return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU)); 1295 if (const TagType *Tag = dyn_cast<TagType>(T)) 1296 return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU)); 1297 if (const TemplateSpecializationType *TST 1298 = dyn_cast<TemplateSpecializationType>(T)) 1299 return VisitTemplateName(TST->getTemplateName(), Range.getBegin()); 1300 break; 1301 } 1302 1303 case NestedNameSpecifier::TypeSpecWithTemplate: 1304 case NestedNameSpecifier::Global: 1305 case NestedNameSpecifier::Identifier: 1306 case NestedNameSpecifier::Super: 1307 break; 1308 } 1309 1310 return false; 1311} 1312 1313bool 1314CursorVisitor::VisitNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) { 1315 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; 1316 for (; Qualifier; Qualifier = Qualifier.getPrefix()) 1317 Qualifiers.push_back(Qualifier); 1318 1319 while (!Qualifiers.empty()) { 1320 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val(); 1321 NestedNameSpecifier *NNS = Q.getNestedNameSpecifier(); 1322 switch (NNS->getKind()) { 1323 case NestedNameSpecifier::Namespace: 1324 if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), 1325 Q.getLocalBeginLoc(), 1326 TU))) 1327 return true; 1328 1329 break; 1330 1331 case NestedNameSpecifier::NamespaceAlias: 1332 if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 1333 Q.getLocalBeginLoc(), 1334 TU))) 1335 return true; 1336 1337 break; 1338 1339 case NestedNameSpecifier::TypeSpec: 1340 case NestedNameSpecifier::TypeSpecWithTemplate: 1341 if (Visit(Q.getTypeLoc())) 1342 return true; 1343 1344 break; 1345 1346 case NestedNameSpecifier::Global: 1347 case NestedNameSpecifier::Identifier: 1348 case NestedNameSpecifier::Super: 1349 break; 1350 } 1351 } 1352 1353 return false; 1354} 1355 1356bool CursorVisitor::VisitTemplateParameters( 1357 const TemplateParameterList *Params) { 1358 if (!Params) 1359 return false; 1360 1361 for (TemplateParameterList::const_iterator P = Params->begin(), 1362 PEnd = Params->end(); 1363 P != PEnd; ++P) { 1364 if (Visit(MakeCXCursor(*P, TU, RegionOfInterest))) 1365 return true; 1366 } 1367 1368 return false; 1369} 1370 1371bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) { 1372 switch (Name.getKind()) { 1373 case TemplateName::Template: 1374 return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU)); 1375 1376 case TemplateName::OverloadedTemplate: 1377 // Visit the overloaded template set. 1378 if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU))) 1379 return true; 1380 1381 return false; 1382 1383 case TemplateName::DependentTemplate: 1384 // FIXME: Visit nested-name-specifier. 1385 return false; 1386 1387 case TemplateName::QualifiedTemplate: 1388 // FIXME: Visit nested-name-specifier. 1389 return Visit(MakeCursorTemplateRef( 1390 Name.getAsQualifiedTemplateName()->getDecl(), 1391 Loc, TU)); 1392 1393 case TemplateName::SubstTemplateTemplateParm: 1394 return Visit(MakeCursorTemplateRef( 1395 Name.getAsSubstTemplateTemplateParm()->getParameter(), 1396 Loc, TU)); 1397 1398 case TemplateName::SubstTemplateTemplateParmPack: 1399 return Visit(MakeCursorTemplateRef( 1400 Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(), 1401 Loc, TU)); 1402 } 1403 1404 llvm_unreachable("Invalid TemplateName::Kind!"); 1405} 1406 1407bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) { 1408 switch (TAL.getArgument().getKind()) { 1409 case TemplateArgument::Null: 1410 case TemplateArgument::Integral: 1411 case TemplateArgument::Pack: 1412 return false; 1413 1414 case TemplateArgument::Type: 1415 if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo()) 1416 return Visit(TSInfo->getTypeLoc()); 1417 return false; 1418 1419 case TemplateArgument::Declaration: 1420 if (Expr *E = TAL.getSourceDeclExpression()) 1421 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1422 return false; 1423 1424 case TemplateArgument::NullPtr: 1425 if (Expr *E = TAL.getSourceNullPtrExpression()) 1426 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1427 return false; 1428 1429 case TemplateArgument::Expression: 1430 if (Expr *E = TAL.getSourceExpression()) 1431 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1432 return false; 1433 1434 case TemplateArgument::Template: 1435 case TemplateArgument::TemplateExpansion: 1436 if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc())) 1437 return true; 1438 1439 return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(), 1440 TAL.getTemplateNameLoc()); 1441 } 1442 1443 llvm_unreachable("Invalid TemplateArgument::Kind!"); 1444} 1445 1446bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 1447 return VisitDeclContext(D); 1448} 1449 1450bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 1451 return Visit(TL.getUnqualifiedLoc()); 1452} 1453 1454bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 1455 ASTContext &Context = AU->getASTContext(); 1456 1457 // Some builtin types (such as Objective-C's "id", "sel", and 1458 // "Class") have associated declarations. Create cursors for those. 1459 QualType VisitType; 1460 switch (TL.getTypePtr()->getKind()) { 1461 1462 case BuiltinType::Void: 1463 case BuiltinType::NullPtr: 1464 case BuiltinType::Dependent: 1465 case BuiltinType::OCLImage1d: 1466 case BuiltinType::OCLImage1dArray: 1467 case BuiltinType::OCLImage1dBuffer: 1468 case BuiltinType::OCLImage2d: 1469 case BuiltinType::OCLImage2dArray: 1470 case BuiltinType::OCLImage2dDepth: 1471 case BuiltinType::OCLImage2dArrayDepth: 1472 case BuiltinType::OCLImage2dMSAA: 1473 case BuiltinType::OCLImage2dArrayMSAA: 1474 case BuiltinType::OCLImage2dMSAADepth: 1475 case BuiltinType::OCLImage2dArrayMSAADepth: 1476 case BuiltinType::OCLImage3d: 1477 case BuiltinType::OCLSampler: 1478 case BuiltinType::OCLEvent: 1479 case BuiltinType::OCLClkEvent: 1480 case BuiltinType::OCLQueue: 1481 case BuiltinType::OCLNDRange: 1482 case BuiltinType::OCLReserveID: 1483#define BUILTIN_TYPE(Id, SingletonId) 1484#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: 1485#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: 1486#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id: 1487#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id: 1488#include "clang/AST/BuiltinTypes.def" 1489 break; 1490 1491 case BuiltinType::ObjCId: 1492 VisitType = Context.getObjCIdType(); 1493 break; 1494 1495 case BuiltinType::ObjCClass: 1496 VisitType = Context.getObjCClassType(); 1497 break; 1498 1499 case BuiltinType::ObjCSel: 1500 VisitType = Context.getObjCSelType(); 1501 break; 1502 } 1503 1504 if (!VisitType.isNull()) { 1505 if (const TypedefType *Typedef = VisitType->getAs<TypedefType>()) 1506 return Visit(MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(), 1507 TU)); 1508 } 1509 1510 return false; 1511} 1512 1513bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 1514 return Visit(MakeCursorTypeRef(TL.getTypedefNameDecl(), TL.getNameLoc(), TU)); 1515} 1516 1517bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 1518 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1519} 1520 1521bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) { 1522 if (TL.isDefinition()) 1523 return Visit(MakeCXCursor(TL.getDecl(), TU, RegionOfInterest)); 1524 1525 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1526} 1527 1528bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 1529 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1530} 1531 1532bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 1533 return Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU)); 1534} 1535 1536bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 1537 if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc())) 1538 return true; 1539 1540 for (unsigned I = 0, N = TL.getNumTypeArgs(); I != N; ++I) { 1541 if (Visit(TL.getTypeArgTInfo(I)->getTypeLoc())) 1542 return true; 1543 } 1544 1545 for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) { 1546 if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I), 1547 TU))) 1548 return true; 1549 } 1550 1551 return false; 1552} 1553 1554bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 1555 return Visit(TL.getPointeeLoc()); 1556} 1557 1558bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) { 1559 return Visit(TL.getInnerLoc()); 1560} 1561 1562bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) { 1563 return Visit(TL.getPointeeLoc()); 1564} 1565 1566bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 1567 return Visit(TL.getPointeeLoc()); 1568} 1569 1570bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 1571 return Visit(TL.getPointeeLoc()); 1572} 1573 1574bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 1575 return Visit(TL.getPointeeLoc()); 1576} 1577 1578bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 1579 return Visit(TL.getPointeeLoc()); 1580} 1581 1582bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 1583 return Visit(TL.getModifiedLoc()); 1584} 1585 1586bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL, 1587 bool SkipResultType) { 1588 if (!SkipResultType && Visit(TL.getReturnLoc())) 1589 return true; 1590 1591 for (unsigned I = 0, N = TL.getNumParams(); I != N; ++I) 1592 if (Decl *D = TL.getParam(I)) 1593 if (Visit(MakeCXCursor(D, TU, RegionOfInterest))) 1594 return true; 1595 1596 return false; 1597} 1598 1599bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) { 1600 if (Visit(TL.getElementLoc())) 1601 return true; 1602 1603 if (Expr *Size = TL.getSizeExpr()) 1604 return Visit(MakeCXCursor(Size, StmtParent, TU, RegionOfInterest)); 1605 1606 return false; 1607} 1608 1609bool CursorVisitor::VisitDecayedTypeLoc(DecayedTypeLoc TL) { 1610 return Visit(TL.getOriginalLoc()); 1611} 1612 1613bool CursorVisitor::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { 1614 return Visit(TL.getOriginalLoc()); 1615} 1616 1617bool CursorVisitor::VisitTemplateSpecializationTypeLoc( 1618 TemplateSpecializationTypeLoc TL) { 1619 // Visit the template name. 1620 if (VisitTemplateName(TL.getTypePtr()->getTemplateName(), 1621 TL.getTemplateNameLoc())) 1622 return true; 1623 1624 // Visit the template arguments. 1625 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1626 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1627 return true; 1628 1629 return false; 1630} 1631 1632bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 1633 return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU)); 1634} 1635 1636bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 1637 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo()) 1638 return Visit(TSInfo->getTypeLoc()); 1639 1640 return false; 1641} 1642 1643bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 1644 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo()) 1645 return Visit(TSInfo->getTypeLoc()); 1646 1647 return false; 1648} 1649 1650bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 1651 return VisitNestedNameSpecifierLoc(TL.getQualifierLoc()); 1652} 1653 1654bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc( 1655 DependentTemplateSpecializationTypeLoc TL) { 1656 // Visit the nested-name-specifier, if there is one. 1657 if (TL.getQualifierLoc() && 1658 VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1659 return true; 1660 1661 // Visit the template arguments. 1662 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1663 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1664 return true; 1665 1666 return false; 1667} 1668 1669bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 1670 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1671 return true; 1672 1673 return Visit(TL.getNamedTypeLoc()); 1674} 1675 1676bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 1677 return Visit(TL.getPatternLoc()); 1678} 1679 1680bool CursorVisitor::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 1681 if (Expr *E = TL.getUnderlyingExpr()) 1682 return Visit(MakeCXCursor(E, StmtParent, TU)); 1683 1684 return false; 1685} 1686 1687bool CursorVisitor::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 1688 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1689} 1690 1691bool CursorVisitor::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 1692 return Visit(TL.getValueLoc()); 1693} 1694 1695#define DEFAULT_TYPELOC_IMPL(CLASS, PARENT) \ 1696bool CursorVisitor::Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { \ 1697 return Visit##PARENT##Loc(TL); \ 1698} 1699 1700DEFAULT_TYPELOC_IMPL(Complex, Type) 1701DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType) 1702DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType) 1703DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType) 1704DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType) 1705DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type) 1706DEFAULT_TYPELOC_IMPL(Vector, Type) 1707DEFAULT_TYPELOC_IMPL(ExtVector, VectorType) 1708DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType) 1709DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType) 1710DEFAULT_TYPELOC_IMPL(Record, TagType) 1711DEFAULT_TYPELOC_IMPL(Enum, TagType) 1712DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type) 1713DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type) 1714DEFAULT_TYPELOC_IMPL(Auto, Type) 1715 1716bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) { 1717 // Visit the nested-name-specifier, if present. 1718 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1719 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1720 return true; 1721 1722 if (D->isCompleteDefinition()) { 1723 for (const auto &I : D->bases()) { 1724 if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(&I, TU))) 1725 return true; 1726 } 1727 } 1728 1729 return VisitTagDecl(D); 1730} 1731 1732bool CursorVisitor::VisitAttributes(Decl *D) { 1733 for (const auto *I : D->attrs()) 1734 if (Visit(MakeCXCursor(I, D, TU))) 1735 return true; 1736 1737 return false; 1738} 1739 1740//===----------------------------------------------------------------------===// 1741// Data-recursive visitor methods. 1742//===----------------------------------------------------------------------===// 1743 1744namespace { 1745#define DEF_JOB(NAME, DATA, KIND)\ 1746class NAME : public VisitorJob {\ 1747public:\ 1748 NAME(const DATA *d, CXCursor parent) : \ 1749 VisitorJob(parent, VisitorJob::KIND, d) {} \ 1750 static bool classof(const VisitorJob *VJ) { return VJ->getKind() == KIND; }\ 1751 const DATA *get() const { return static_cast<const DATA*>(data[0]); }\ 1752}; 1753 1754DEF_JOB(StmtVisit, Stmt, StmtVisitKind) 1755DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind) 1756DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind) 1757DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind) 1758DEF_JOB(ExplicitTemplateArgsVisit, ASTTemplateArgumentListInfo, 1759 ExplicitTemplateArgsVisitKind) 1760DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind) 1761DEF_JOB(LambdaExprParts, LambdaExpr, LambdaExprPartsKind) 1762DEF_JOB(PostChildrenVisit, void, PostChildrenVisitKind) 1763#undef DEF_JOB 1764 1765class DeclVisit : public VisitorJob { 1766public: 1767 DeclVisit(const Decl *D, CXCursor parent, bool isFirst) : 1768 VisitorJob(parent, VisitorJob::DeclVisitKind, 1769 D, isFirst ? (void*) 1 : (void*) nullptr) {} 1770 static bool classof(const VisitorJob *VJ) { 1771 return VJ->getKind() == DeclVisitKind; 1772 } 1773 const Decl *get() const { return static_cast<const Decl *>(data[0]); } 1774 bool isFirst() const { return data[1] != nullptr; } 1775}; 1776class TypeLocVisit : public VisitorJob { 1777public: 1778 TypeLocVisit(TypeLoc tl, CXCursor parent) : 1779 VisitorJob(parent, VisitorJob::TypeLocVisitKind, 1780 tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {} 1781 1782 static bool classof(const VisitorJob *VJ) { 1783 return VJ->getKind() == TypeLocVisitKind; 1784 } 1785 1786 TypeLoc get() const { 1787 QualType T = QualType::getFromOpaquePtr(data[0]); 1788 return TypeLoc(T, const_cast<void *>(data[1])); 1789 } 1790}; 1791 1792class LabelRefVisit : public VisitorJob { 1793public: 1794 LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent) 1795 : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD, 1796 labelLoc.getPtrEncoding()) {} 1797 1798 static bool classof(const VisitorJob *VJ) { 1799 return VJ->getKind() == VisitorJob::LabelRefVisitKind; 1800 } 1801 const LabelDecl *get() const { 1802 return static_cast<const LabelDecl *>(data[0]); 1803 } 1804 SourceLocation getLoc() const { 1805 return SourceLocation::getFromPtrEncoding(data[1]); } 1806}; 1807 1808class NestedNameSpecifierLocVisit : public VisitorJob { 1809public: 1810 NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent) 1811 : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind, 1812 Qualifier.getNestedNameSpecifier(), 1813 Qualifier.getOpaqueData()) { } 1814 1815 static bool classof(const VisitorJob *VJ) { 1816 return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind; 1817 } 1818 1819 NestedNameSpecifierLoc get() const { 1820 return NestedNameSpecifierLoc( 1821 const_cast<NestedNameSpecifier *>( 1822 static_cast<const NestedNameSpecifier *>(data[0])), 1823 const_cast<void *>(data[1])); 1824 } 1825}; 1826 1827class DeclarationNameInfoVisit : public VisitorJob { 1828public: 1829 DeclarationNameInfoVisit(const Stmt *S, CXCursor parent) 1830 : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {} 1831 static bool classof(const VisitorJob *VJ) { 1832 return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind; 1833 } 1834 DeclarationNameInfo get() const { 1835 const Stmt *S = static_cast<const Stmt *>(data[0]); 1836 switch (S->getStmtClass()) { 1837 default: 1838 llvm_unreachable("Unhandled Stmt"); 1839 case clang::Stmt::MSDependentExistsStmtClass: 1840 return cast<MSDependentExistsStmt>(S)->getNameInfo(); 1841 case Stmt::CXXDependentScopeMemberExprClass: 1842 return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo(); 1843 case Stmt::DependentScopeDeclRefExprClass: 1844 return cast<DependentScopeDeclRefExpr>(S)->getNameInfo(); 1845 case Stmt::OMPCriticalDirectiveClass: 1846 return cast<OMPCriticalDirective>(S)->getDirectiveName(); 1847 } 1848 } 1849}; 1850class MemberRefVisit : public VisitorJob { 1851public: 1852 MemberRefVisit(const FieldDecl *D, SourceLocation L, CXCursor parent) 1853 : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D, 1854 L.getPtrEncoding()) {} 1855 static bool classof(const VisitorJob *VJ) { 1856 return VJ->getKind() == VisitorJob::MemberRefVisitKind; 1857 } 1858 const FieldDecl *get() const { 1859 return static_cast<const FieldDecl *>(data[0]); 1860 } 1861 SourceLocation getLoc() const { 1862 return SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[1]); 1863 } 1864}; 1865class EnqueueVisitor : public ConstStmtVisitor<EnqueueVisitor, void> { 1866 friend class OMPClauseEnqueue; 1867 VisitorWorkList &WL; 1868 CXCursor Parent; 1869public: 1870 EnqueueVisitor(VisitorWorkList &wl, CXCursor parent) 1871 : WL(wl), Parent(parent) {} 1872 1873 void VisitAddrLabelExpr(const AddrLabelExpr *E); 1874 void VisitBlockExpr(const BlockExpr *B); 1875 void VisitCompoundLiteralExpr(const CompoundLiteralExpr *E); 1876 void VisitCompoundStmt(const CompoundStmt *S); 1877 void VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) { /* Do nothing. */ } 1878 void VisitMSDependentExistsStmt(const MSDependentExistsStmt *S); 1879 void VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E); 1880 void VisitCXXNewExpr(const CXXNewExpr *E); 1881 void VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E); 1882 void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *E); 1883 void VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E); 1884 void VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E); 1885 void VisitCXXTypeidExpr(const CXXTypeidExpr *E); 1886 void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *E); 1887 void VisitCXXUuidofExpr(const CXXUuidofExpr *E); 1888 void VisitCXXCatchStmt(const CXXCatchStmt *S); 1889 void VisitCXXForRangeStmt(const CXXForRangeStmt *S); 1890 void VisitDeclRefExpr(const DeclRefExpr *D); 1891 void VisitDeclStmt(const DeclStmt *S); 1892 void VisitDependentScopeDeclRefExpr(const DependentScopeDeclRefExpr *E); 1893 void VisitDesignatedInitExpr(const DesignatedInitExpr *E); 1894 void VisitExplicitCastExpr(const ExplicitCastExpr *E); 1895 void VisitForStmt(const ForStmt *FS); 1896 void VisitGotoStmt(const GotoStmt *GS); 1897 void VisitIfStmt(const IfStmt *If); 1898 void VisitInitListExpr(const InitListExpr *IE); 1899 void VisitMemberExpr(const MemberExpr *M); 1900 void VisitOffsetOfExpr(const OffsetOfExpr *E); 1901 void VisitObjCEncodeExpr(const ObjCEncodeExpr *E); 1902 void VisitObjCMessageExpr(const ObjCMessageExpr *M); 1903 void VisitOverloadExpr(const OverloadExpr *E); 1904 void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E); 1905 void VisitStmt(const Stmt *S); 1906 void VisitSwitchStmt(const SwitchStmt *S); 1907 void VisitWhileStmt(const WhileStmt *W); 1908 void VisitTypeTraitExpr(const TypeTraitExpr *E); 1909 void VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E); 1910 void VisitExpressionTraitExpr(const ExpressionTraitExpr *E); 1911 void VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U); 1912 void VisitVAArgExpr(const VAArgExpr *E); 1913 void VisitSizeOfPackExpr(const SizeOfPackExpr *E); 1914 void VisitPseudoObjectExpr(const PseudoObjectExpr *E); 1915 void VisitOpaqueValueExpr(const OpaqueValueExpr *E); 1916 void VisitLambdaExpr(const LambdaExpr *E); 1917 void VisitOMPExecutableDirective(const OMPExecutableDirective *D); 1918 void VisitOMPLoopDirective(const OMPLoopDirective *D); 1919 void VisitOMPParallelDirective(const OMPParallelDirective *D); 1920 void VisitOMPSimdDirective(const OMPSimdDirective *D); 1921 void VisitOMPForDirective(const OMPForDirective *D); 1922 void VisitOMPForSimdDirective(const OMPForSimdDirective *D); 1923 void VisitOMPSectionsDirective(const OMPSectionsDirective *D); 1924 void VisitOMPSectionDirective(const OMPSectionDirective *D); 1925 void VisitOMPSingleDirective(const OMPSingleDirective *D); 1926 void VisitOMPMasterDirective(const OMPMasterDirective *D); 1927 void VisitOMPCriticalDirective(const OMPCriticalDirective *D); 1928 void VisitOMPParallelForDirective(const OMPParallelForDirective *D); 1929 void VisitOMPParallelForSimdDirective(const OMPParallelForSimdDirective *D); 1930 void VisitOMPParallelSectionsDirective(const OMPParallelSectionsDirective *D); 1931 void VisitOMPTaskDirective(const OMPTaskDirective *D); 1932 void VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D); 1933 void VisitOMPBarrierDirective(const OMPBarrierDirective *D); 1934 void VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D); 1935 void VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *D); 1936 void 1937 VisitOMPCancellationPointDirective(const OMPCancellationPointDirective *D); 1938 void VisitOMPCancelDirective(const OMPCancelDirective *D); 1939 void VisitOMPFlushDirective(const OMPFlushDirective *D); 1940 void VisitOMPOrderedDirective(const OMPOrderedDirective *D); 1941 void VisitOMPAtomicDirective(const OMPAtomicDirective *D); 1942 void VisitOMPTargetDirective(const OMPTargetDirective *D); 1943 void VisitOMPTargetDataDirective(const OMPTargetDataDirective *D); 1944 void VisitOMPTeamsDirective(const OMPTeamsDirective *D); 1945 void VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D); 1946 void VisitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective *D); 1947 void VisitOMPDistributeDirective(const OMPDistributeDirective *D); 1948 1949private: 1950 void AddDeclarationNameInfo(const Stmt *S); 1951 void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier); 1952 void AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A); 1953 void AddMemberRef(const FieldDecl *D, SourceLocation L); 1954 void AddStmt(const Stmt *S); 1955 void AddDecl(const Decl *D, bool isFirst = true); 1956 void AddTypeLoc(TypeSourceInfo *TI); 1957 void EnqueueChildren(const Stmt *S); 1958 void EnqueueChildren(const OMPClause *S); 1959}; 1960} // end anonyous namespace 1961 1962void EnqueueVisitor::AddDeclarationNameInfo(const Stmt *S) { 1963 // 'S' should always be non-null, since it comes from the 1964 // statement we are visiting. 1965 WL.push_back(DeclarationNameInfoVisit(S, Parent)); 1966} 1967 1968void 1969EnqueueVisitor::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) { 1970 if (Qualifier) 1971 WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent)); 1972} 1973 1974void EnqueueVisitor::AddStmt(const Stmt *S) { 1975 if (S) 1976 WL.push_back(StmtVisit(S, Parent)); 1977} 1978void EnqueueVisitor::AddDecl(const Decl *D, bool isFirst) { 1979 if (D) 1980 WL.push_back(DeclVisit(D, Parent, isFirst)); 1981} 1982void EnqueueVisitor:: 1983 AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A) { 1984 if (A) 1985 WL.push_back(ExplicitTemplateArgsVisit(A, Parent)); 1986} 1987void EnqueueVisitor::AddMemberRef(const FieldDecl *D, SourceLocation L) { 1988 if (D) 1989 WL.push_back(MemberRefVisit(D, L, Parent)); 1990} 1991void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) { 1992 if (TI) 1993 WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent)); 1994 } 1995void EnqueueVisitor::EnqueueChildren(const Stmt *S) { 1996 unsigned size = WL.size(); 1997 for (const Stmt *SubStmt : S->children()) { 1998 AddStmt(SubStmt); 1999 } 2000 if (size == WL.size()) 2001 return; 2002 // Now reverse the entries we just added. This will match the DFS 2003 // ordering performed by the worklist. 2004 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 2005 std::reverse(I, E); 2006} 2007namespace { 2008class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> { 2009 EnqueueVisitor *Visitor; 2010 /// \brief Process clauses with list of variables. 2011 template <typename T> 2012 void VisitOMPClauseList(T *Node); 2013public: 2014 OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) { } 2015#define OPENMP_CLAUSE(Name, Class) \ 2016 void Visit##Class(const Class *C); 2017#include "clang/Basic/OpenMPKinds.def" 2018}; 2019 2020void OMPClauseEnqueue::VisitOMPIfClause(const OMPIfClause *C) { 2021 Visitor->AddStmt(C->getCondition()); 2022} 2023 2024void OMPClauseEnqueue::VisitOMPFinalClause(const OMPFinalClause *C) { 2025 Visitor->AddStmt(C->getCondition()); 2026} 2027 2028void OMPClauseEnqueue::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) { 2029 Visitor->AddStmt(C->getNumThreads()); 2030} 2031 2032void OMPClauseEnqueue::VisitOMPSafelenClause(const OMPSafelenClause *C) { 2033 Visitor->AddStmt(C->getSafelen()); 2034} 2035 2036void OMPClauseEnqueue::VisitOMPSimdlenClause(const OMPSimdlenClause *C) { 2037 Visitor->AddStmt(C->getSimdlen()); 2038} 2039 2040void OMPClauseEnqueue::VisitOMPCollapseClause(const OMPCollapseClause *C) { 2041 Visitor->AddStmt(C->getNumForLoops()); 2042} 2043 2044void OMPClauseEnqueue::VisitOMPDefaultClause(const OMPDefaultClause *C) { } 2045 2046void OMPClauseEnqueue::VisitOMPProcBindClause(const OMPProcBindClause *C) { } 2047 2048void OMPClauseEnqueue::VisitOMPScheduleClause(const OMPScheduleClause *C) { 2049 Visitor->AddStmt(C->getChunkSize()); 2050 Visitor->AddStmt(C->getHelperChunkSize()); 2051} 2052 2053void OMPClauseEnqueue::VisitOMPOrderedClause(const OMPOrderedClause *C) { 2054 Visitor->AddStmt(C->getNumForLoops()); 2055} 2056 2057void OMPClauseEnqueue::VisitOMPNowaitClause(const OMPNowaitClause *) {} 2058 2059void OMPClauseEnqueue::VisitOMPUntiedClause(const OMPUntiedClause *) {} 2060 2061void OMPClauseEnqueue::VisitOMPMergeableClause(const OMPMergeableClause *) {} 2062 2063void OMPClauseEnqueue::VisitOMPReadClause(const OMPReadClause *) {} 2064 2065void OMPClauseEnqueue::VisitOMPWriteClause(const OMPWriteClause *) {} 2066 2067void OMPClauseEnqueue::VisitOMPUpdateClause(const OMPUpdateClause *) {} 2068 2069void OMPClauseEnqueue::VisitOMPCaptureClause(const OMPCaptureClause *) {} 2070 2071void OMPClauseEnqueue::VisitOMPSeqCstClause(const OMPSeqCstClause *) {} 2072 2073void OMPClauseEnqueue::VisitOMPThreadsClause(const OMPThreadsClause *) {} 2074 2075void OMPClauseEnqueue::VisitOMPSIMDClause(const OMPSIMDClause *) {} 2076 2077void OMPClauseEnqueue::VisitOMPNogroupClause(const OMPNogroupClause *) {} 2078 2079void OMPClauseEnqueue::VisitOMPDeviceClause(const OMPDeviceClause *C) { 2080 Visitor->AddStmt(C->getDevice()); 2081} 2082 2083void OMPClauseEnqueue::VisitOMPNumTeamsClause(const OMPNumTeamsClause *C) { 2084 Visitor->AddStmt(C->getNumTeams()); 2085} 2086 2087void OMPClauseEnqueue::VisitOMPThreadLimitClause(const OMPThreadLimitClause *C) { 2088 Visitor->AddStmt(C->getThreadLimit()); 2089} 2090 2091void OMPClauseEnqueue::VisitOMPPriorityClause(const OMPPriorityClause *C) { 2092 Visitor->AddStmt(C->getPriority()); 2093} 2094 2095void OMPClauseEnqueue::VisitOMPGrainsizeClause(const OMPGrainsizeClause *C) { 2096 Visitor->AddStmt(C->getGrainsize()); 2097} 2098 2099void OMPClauseEnqueue::VisitOMPNumTasksClause(const OMPNumTasksClause *C) { 2100 Visitor->AddStmt(C->getNumTasks()); 2101} 2102 2103void OMPClauseEnqueue::VisitOMPHintClause(const OMPHintClause *C) { 2104 Visitor->AddStmt(C->getHint()); 2105} 2106 2107template<typename T> 2108void OMPClauseEnqueue::VisitOMPClauseList(T *Node) { 2109 for (const auto *I : Node->varlists()) { 2110 Visitor->AddStmt(I); 2111 } 2112} 2113 2114void OMPClauseEnqueue::VisitOMPPrivateClause(const OMPPrivateClause *C) { 2115 VisitOMPClauseList(C); 2116 for (const auto *E : C->private_copies()) { 2117 Visitor->AddStmt(E); 2118 } 2119} 2120void OMPClauseEnqueue::VisitOMPFirstprivateClause( 2121 const OMPFirstprivateClause *C) { 2122 VisitOMPClauseList(C); 2123} 2124void OMPClauseEnqueue::VisitOMPLastprivateClause( 2125 const OMPLastprivateClause *C) { 2126 VisitOMPClauseList(C); 2127 for (auto *E : C->private_copies()) { 2128 Visitor->AddStmt(E); 2129 } 2130 for (auto *E : C->source_exprs()) { 2131 Visitor->AddStmt(E); 2132 } 2133 for (auto *E : C->destination_exprs()) { 2134 Visitor->AddStmt(E); 2135 } 2136 for (auto *E : C->assignment_ops()) { 2137 Visitor->AddStmt(E); 2138 } 2139} 2140void OMPClauseEnqueue::VisitOMPSharedClause(const OMPSharedClause *C) { 2141 VisitOMPClauseList(C); 2142} 2143void OMPClauseEnqueue::VisitOMPReductionClause(const OMPReductionClause *C) { 2144 VisitOMPClauseList(C); 2145 for (auto *E : C->privates()) { 2146 Visitor->AddStmt(E); 2147 } 2148 for (auto *E : C->lhs_exprs()) { 2149 Visitor->AddStmt(E); 2150 } 2151 for (auto *E : C->rhs_exprs()) { 2152 Visitor->AddStmt(E); 2153 } 2154 for (auto *E : C->reduction_ops()) { 2155 Visitor->AddStmt(E); 2156 } 2157} 2158void OMPClauseEnqueue::VisitOMPLinearClause(const OMPLinearClause *C) { 2159 VisitOMPClauseList(C); 2160 for (const auto *E : C->privates()) { 2161 Visitor->AddStmt(E); 2162 } 2163 for (const auto *E : C->inits()) { 2164 Visitor->AddStmt(E); 2165 } 2166 for (const auto *E : C->updates()) { 2167 Visitor->AddStmt(E); 2168 } 2169 for (const auto *E : C->finals()) { 2170 Visitor->AddStmt(E); 2171 } 2172 Visitor->AddStmt(C->getStep()); 2173 Visitor->AddStmt(C->getCalcStep()); 2174} 2175void OMPClauseEnqueue::VisitOMPAlignedClause(const OMPAlignedClause *C) { 2176 VisitOMPClauseList(C); 2177 Visitor->AddStmt(C->getAlignment()); 2178} 2179void OMPClauseEnqueue::VisitOMPCopyinClause(const OMPCopyinClause *C) { 2180 VisitOMPClauseList(C); 2181 for (auto *E : C->source_exprs()) { 2182 Visitor->AddStmt(E); 2183 } 2184 for (auto *E : C->destination_exprs()) { 2185 Visitor->AddStmt(E); 2186 } 2187 for (auto *E : C->assignment_ops()) { 2188 Visitor->AddStmt(E); 2189 } 2190} 2191void 2192OMPClauseEnqueue::VisitOMPCopyprivateClause(const OMPCopyprivateClause *C) { 2193 VisitOMPClauseList(C); 2194 for (auto *E : C->source_exprs()) { 2195 Visitor->AddStmt(E); 2196 } 2197 for (auto *E : C->destination_exprs()) { 2198 Visitor->AddStmt(E); 2199 } 2200 for (auto *E : C->assignment_ops()) { 2201 Visitor->AddStmt(E); 2202 } 2203} 2204void OMPClauseEnqueue::VisitOMPFlushClause(const OMPFlushClause *C) { 2205 VisitOMPClauseList(C); 2206} 2207void OMPClauseEnqueue::VisitOMPDependClause(const OMPDependClause *C) { 2208 VisitOMPClauseList(C); 2209} 2210void OMPClauseEnqueue::VisitOMPMapClause(const OMPMapClause *C) { 2211 VisitOMPClauseList(C); 2212} 2213} 2214 2215void EnqueueVisitor::EnqueueChildren(const OMPClause *S) { 2216 unsigned size = WL.size(); 2217 OMPClauseEnqueue Visitor(this); 2218 Visitor.Visit(S); 2219 if (size == WL.size()) 2220 return; 2221 // Now reverse the entries we just added. This will match the DFS 2222 // ordering performed by the worklist. 2223 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 2224 std::reverse(I, E); 2225} 2226void EnqueueVisitor::VisitAddrLabelExpr(const AddrLabelExpr *E) { 2227 WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent)); 2228} 2229void EnqueueVisitor::VisitBlockExpr(const BlockExpr *B) { 2230 AddDecl(B->getBlockDecl()); 2231} 2232void EnqueueVisitor::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) { 2233 EnqueueChildren(E); 2234 AddTypeLoc(E->getTypeSourceInfo()); 2235} 2236void EnqueueVisitor::VisitCompoundStmt(const CompoundStmt *S) { 2237 for (auto &I : llvm::reverse(S->body())) 2238 AddStmt(I); 2239} 2240void EnqueueVisitor:: 2241VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) { 2242 AddStmt(S->getSubStmt()); 2243 AddDeclarationNameInfo(S); 2244 if (NestedNameSpecifierLoc QualifierLoc = S->getQualifierLoc()) 2245 AddNestedNameSpecifierLoc(QualifierLoc); 2246} 2247 2248void EnqueueVisitor:: 2249VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E) { 2250 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 2251 AddDeclarationNameInfo(E); 2252 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 2253 AddNestedNameSpecifierLoc(QualifierLoc); 2254 if (!E->isImplicitAccess()) 2255 AddStmt(E->getBase()); 2256} 2257void EnqueueVisitor::VisitCXXNewExpr(const CXXNewExpr *E) { 2258 // Enqueue the initializer , if any. 2259 AddStmt(E->getInitializer()); 2260 // Enqueue the array size, if any. 2261 AddStmt(E->getArraySize()); 2262 // Enqueue the allocated type. 2263 AddTypeLoc(E->getAllocatedTypeSourceInfo()); 2264 // Enqueue the placement arguments. 2265 for (unsigned I = E->getNumPlacementArgs(); I > 0; --I) 2266 AddStmt(E->getPlacementArg(I-1)); 2267} 2268void EnqueueVisitor::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *CE) { 2269 for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I) 2270 AddStmt(CE->getArg(I-1)); 2271 AddStmt(CE->getCallee()); 2272 AddStmt(CE->getArg(0)); 2273} 2274void EnqueueVisitor::VisitCXXPseudoDestructorExpr( 2275 const CXXPseudoDestructorExpr *E) { 2276 // Visit the name of the type being destroyed. 2277 AddTypeLoc(E->getDestroyedTypeInfo()); 2278 // Visit the scope type that looks disturbingly like the nested-name-specifier 2279 // but isn't. 2280 AddTypeLoc(E->getScopeTypeInfo()); 2281 // Visit the nested-name-specifier. 2282 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 2283 AddNestedNameSpecifierLoc(QualifierLoc); 2284 // Visit base expression. 2285 AddStmt(E->getBase()); 2286} 2287void EnqueueVisitor::VisitCXXScalarValueInitExpr( 2288 const CXXScalarValueInitExpr *E) { 2289 AddTypeLoc(E->getTypeSourceInfo()); 2290} 2291void EnqueueVisitor::VisitCXXTemporaryObjectExpr( 2292 const CXXTemporaryObjectExpr *E) { 2293 EnqueueChildren(E); 2294 AddTypeLoc(E->getTypeSourceInfo()); 2295} 2296void EnqueueVisitor::VisitCXXTypeidExpr(const CXXTypeidExpr *E) { 2297 EnqueueChildren(E); 2298 if (E->isTypeOperand()) 2299 AddTypeLoc(E->getTypeOperandSourceInfo()); 2300} 2301 2302void EnqueueVisitor::VisitCXXUnresolvedConstructExpr( 2303 const CXXUnresolvedConstructExpr *E) { 2304 EnqueueChildren(E); 2305 AddTypeLoc(E->getTypeSourceInfo()); 2306} 2307void EnqueueVisitor::VisitCXXUuidofExpr(const CXXUuidofExpr *E) { 2308 EnqueueChildren(E); 2309 if (E->isTypeOperand()) 2310 AddTypeLoc(E->getTypeOperandSourceInfo()); 2311} 2312 2313void EnqueueVisitor::VisitCXXCatchStmt(const CXXCatchStmt *S) { 2314 EnqueueChildren(S); 2315 AddDecl(S->getExceptionDecl()); 2316} 2317 2318void EnqueueVisitor::VisitCXXForRangeStmt(const CXXForRangeStmt *S) { 2319 AddStmt(S->getBody()); 2320 AddStmt(S->getRangeInit()); 2321 AddDecl(S->getLoopVariable()); 2322} 2323 2324void EnqueueVisitor::VisitDeclRefExpr(const DeclRefExpr *DR) { 2325 if (DR->hasExplicitTemplateArgs()) { 2326 AddExplicitTemplateArgs(&DR->getExplicitTemplateArgs()); 2327 } 2328 WL.push_back(DeclRefExprParts(DR, Parent)); 2329} 2330void EnqueueVisitor::VisitDependentScopeDeclRefExpr( 2331 const DependentScopeDeclRefExpr *E) { 2332 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 2333 AddDeclarationNameInfo(E); 2334 AddNestedNameSpecifierLoc(E->getQualifierLoc()); 2335} 2336void EnqueueVisitor::VisitDeclStmt(const DeclStmt *S) { 2337 unsigned size = WL.size(); 2338 bool isFirst = true; 2339 for (const auto *D : S->decls()) { 2340 AddDecl(D, isFirst); 2341 isFirst = false; 2342 } 2343 if (size == WL.size()) 2344 return; 2345 // Now reverse the entries we just added. This will match the DFS 2346 // ordering performed by the worklist. 2347 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 2348 std::reverse(I, E); 2349} 2350void EnqueueVisitor::VisitDesignatedInitExpr(const DesignatedInitExpr *E) { 2351 AddStmt(E->getInit()); 2352 for (DesignatedInitExpr::const_reverse_designators_iterator 2353 D = E->designators_rbegin(), DEnd = E->designators_rend(); 2354 D != DEnd; ++D) { 2355 if (D->isFieldDesignator()) { 2356 if (FieldDecl *Field = D->getField()) 2357 AddMemberRef(Field, D->getFieldLoc()); 2358 continue; 2359 } 2360 if (D->isArrayDesignator()) { 2361 AddStmt(E->getArrayIndex(*D)); 2362 continue; 2363 } 2364 assert(D->isArrayRangeDesignator() && "Unknown designator kind"); 2365 AddStmt(E->getArrayRangeEnd(*D)); 2366 AddStmt(E->getArrayRangeStart(*D)); 2367 } 2368} 2369void EnqueueVisitor::VisitExplicitCastExpr(const ExplicitCastExpr *E) { 2370 EnqueueChildren(E); 2371 AddTypeLoc(E->getTypeInfoAsWritten()); 2372} 2373void EnqueueVisitor::VisitForStmt(const ForStmt *FS) { 2374 AddStmt(FS->getBody()); 2375 AddStmt(FS->getInc()); 2376 AddStmt(FS->getCond()); 2377 AddDecl(FS->getConditionVariable()); 2378 AddStmt(FS->getInit()); 2379} 2380void EnqueueVisitor::VisitGotoStmt(const GotoStmt *GS) { 2381 WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent)); 2382} 2383void EnqueueVisitor::VisitIfStmt(const IfStmt *If) { 2384 AddStmt(If->getElse()); 2385 AddStmt(If->getThen()); 2386 AddStmt(If->getCond()); 2387 AddDecl(If->getConditionVariable()); 2388} 2389void EnqueueVisitor::VisitInitListExpr(const InitListExpr *IE) { 2390 // We care about the syntactic form of the initializer list, only. 2391 if (InitListExpr *Syntactic = IE->getSyntacticForm()) 2392 IE = Syntactic; 2393 EnqueueChildren(IE); 2394} 2395void EnqueueVisitor::VisitMemberExpr(const MemberExpr *M) { 2396 WL.push_back(MemberExprParts(M, Parent)); 2397 2398 // If the base of the member access expression is an implicit 'this', don't 2399 // visit it. 2400 // FIXME: If we ever want to show these implicit accesses, this will be 2401 // unfortunate. However, clang_getCursor() relies on this behavior. 2402 if (M->isImplicitAccess()) 2403 return; 2404 2405 // Ignore base anonymous struct/union fields, otherwise they will shadow the 2406 // real field that that we are interested in. 2407 if (auto *SubME = dyn_cast<MemberExpr>(M->getBase())) { 2408 if (auto *FD = dyn_cast_or_null<FieldDecl>(SubME->getMemberDecl())) { 2409 if (FD->isAnonymousStructOrUnion()) { 2410 AddStmt(SubME->getBase()); 2411 return; 2412 } 2413 } 2414 } 2415 2416 AddStmt(M->getBase()); 2417} 2418void EnqueueVisitor::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { 2419 AddTypeLoc(E->getEncodedTypeSourceInfo()); 2420} 2421void EnqueueVisitor::VisitObjCMessageExpr(const ObjCMessageExpr *M) { 2422 EnqueueChildren(M); 2423 AddTypeLoc(M->getClassReceiverTypeInfo()); 2424} 2425void EnqueueVisitor::VisitOffsetOfExpr(const OffsetOfExpr *E) { 2426 // Visit the components of the offsetof expression. 2427 for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) { 2428 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode; 2429 const OffsetOfNode &Node = E->getComponent(I-1); 2430 switch (Node.getKind()) { 2431 case OffsetOfNode::Array: 2432 AddStmt(E->getIndexExpr(Node.getArrayExprIndex())); 2433 break; 2434 case OffsetOfNode::Field: 2435 AddMemberRef(Node.getField(), Node.getSourceRange().getEnd()); 2436 break; 2437 case OffsetOfNode::Identifier: 2438 case OffsetOfNode::Base: 2439 continue; 2440 } 2441 } 2442 // Visit the type into which we're computing the offset. 2443 AddTypeLoc(E->getTypeSourceInfo()); 2444} 2445void EnqueueVisitor::VisitOverloadExpr(const OverloadExpr *E) { 2446 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 2447 WL.push_back(OverloadExprParts(E, Parent)); 2448} 2449void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr( 2450 const UnaryExprOrTypeTraitExpr *E) { 2451 EnqueueChildren(E); 2452 if (E->isArgumentType()) 2453 AddTypeLoc(E->getArgumentTypeInfo()); 2454} 2455void EnqueueVisitor::VisitStmt(const Stmt *S) { 2456 EnqueueChildren(S); 2457} 2458void EnqueueVisitor::VisitSwitchStmt(const SwitchStmt *S) { 2459 AddStmt(S->getBody()); 2460 AddStmt(S->getCond()); 2461 AddDecl(S->getConditionVariable()); 2462} 2463 2464void EnqueueVisitor::VisitWhileStmt(const WhileStmt *W) { 2465 AddStmt(W->getBody()); 2466 AddStmt(W->getCond()); 2467 AddDecl(W->getConditionVariable()); 2468} 2469 2470void EnqueueVisitor::VisitTypeTraitExpr(const TypeTraitExpr *E) { 2471 for (unsigned I = E->getNumArgs(); I > 0; --I) 2472 AddTypeLoc(E->getArg(I-1)); 2473} 2474 2475void EnqueueVisitor::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) { 2476 AddTypeLoc(E->getQueriedTypeSourceInfo()); 2477} 2478 2479void EnqueueVisitor::VisitExpressionTraitExpr(const ExpressionTraitExpr *E) { 2480 EnqueueChildren(E); 2481} 2482 2483void EnqueueVisitor::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U) { 2484 VisitOverloadExpr(U); 2485 if (!U->isImplicitAccess()) 2486 AddStmt(U->getBase()); 2487} 2488void EnqueueVisitor::VisitVAArgExpr(const VAArgExpr *E) { 2489 AddStmt(E->getSubExpr()); 2490 AddTypeLoc(E->getWrittenTypeInfo()); 2491} 2492void EnqueueVisitor::VisitSizeOfPackExpr(const SizeOfPackExpr *E) { 2493 WL.push_back(SizeOfPackExprParts(E, Parent)); 2494} 2495void EnqueueVisitor::VisitOpaqueValueExpr(const OpaqueValueExpr *E) { 2496 // If the opaque value has a source expression, just transparently 2497 // visit that. This is useful for (e.g.) pseudo-object expressions. 2498 if (Expr *SourceExpr = E->getSourceExpr()) 2499 return Visit(SourceExpr); 2500} 2501void EnqueueVisitor::VisitLambdaExpr(const LambdaExpr *E) { 2502 AddStmt(E->getBody()); 2503 WL.push_back(LambdaExprParts(E, Parent)); 2504} 2505void EnqueueVisitor::VisitPseudoObjectExpr(const PseudoObjectExpr *E) { 2506 // Treat the expression like its syntactic form. 2507 Visit(E->getSyntacticForm()); 2508} 2509 2510void EnqueueVisitor::VisitOMPExecutableDirective( 2511 const OMPExecutableDirective *D) { 2512 EnqueueChildren(D); 2513 for (ArrayRef<OMPClause *>::iterator I = D->clauses().begin(), 2514 E = D->clauses().end(); 2515 I != E; ++I) 2516 EnqueueChildren(*I); 2517} 2518 2519void EnqueueVisitor::VisitOMPLoopDirective(const OMPLoopDirective *D) { 2520 VisitOMPExecutableDirective(D); 2521} 2522 2523void EnqueueVisitor::VisitOMPParallelDirective(const OMPParallelDirective *D) { 2524 VisitOMPExecutableDirective(D); 2525} 2526 2527void EnqueueVisitor::VisitOMPSimdDirective(const OMPSimdDirective *D) { 2528 VisitOMPLoopDirective(D); 2529} 2530 2531void EnqueueVisitor::VisitOMPForDirective(const OMPForDirective *D) { 2532 VisitOMPLoopDirective(D); 2533} 2534 2535void EnqueueVisitor::VisitOMPForSimdDirective(const OMPForSimdDirective *D) { 2536 VisitOMPLoopDirective(D); 2537} 2538 2539void EnqueueVisitor::VisitOMPSectionsDirective(const OMPSectionsDirective *D) { 2540 VisitOMPExecutableDirective(D); 2541} 2542 2543void EnqueueVisitor::VisitOMPSectionDirective(const OMPSectionDirective *D) { 2544 VisitOMPExecutableDirective(D); 2545} 2546 2547void EnqueueVisitor::VisitOMPSingleDirective(const OMPSingleDirective *D) { 2548 VisitOMPExecutableDirective(D); 2549} 2550 2551void EnqueueVisitor::VisitOMPMasterDirective(const OMPMasterDirective *D) { 2552 VisitOMPExecutableDirective(D); 2553} 2554 2555void EnqueueVisitor::VisitOMPCriticalDirective(const OMPCriticalDirective *D) { 2556 VisitOMPExecutableDirective(D); 2557 AddDeclarationNameInfo(D); 2558} 2559 2560void 2561EnqueueVisitor::VisitOMPParallelForDirective(const OMPParallelForDirective *D) { 2562 VisitOMPLoopDirective(D); 2563} 2564 2565void EnqueueVisitor::VisitOMPParallelForSimdDirective( 2566 const OMPParallelForSimdDirective *D) { 2567 VisitOMPLoopDirective(D); 2568} 2569 2570void EnqueueVisitor::VisitOMPParallelSectionsDirective( 2571 const OMPParallelSectionsDirective *D) { 2572 VisitOMPExecutableDirective(D); 2573} 2574 2575void EnqueueVisitor::VisitOMPTaskDirective(const OMPTaskDirective *D) { 2576 VisitOMPExecutableDirective(D); 2577} 2578 2579void 2580EnqueueVisitor::VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D) { 2581 VisitOMPExecutableDirective(D); 2582} 2583 2584void EnqueueVisitor::VisitOMPBarrierDirective(const OMPBarrierDirective *D) { 2585 VisitOMPExecutableDirective(D); 2586} 2587 2588void EnqueueVisitor::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D) { 2589 VisitOMPExecutableDirective(D); 2590} 2591 2592void EnqueueVisitor::VisitOMPTaskgroupDirective( 2593 const OMPTaskgroupDirective *D) { 2594 VisitOMPExecutableDirective(D); 2595} 2596 2597void EnqueueVisitor::VisitOMPFlushDirective(const OMPFlushDirective *D) { 2598 VisitOMPExecutableDirective(D); 2599} 2600 2601void EnqueueVisitor::VisitOMPOrderedDirective(const OMPOrderedDirective *D) { 2602 VisitOMPExecutableDirective(D); 2603} 2604 2605void EnqueueVisitor::VisitOMPAtomicDirective(const OMPAtomicDirective *D) { 2606 VisitOMPExecutableDirective(D); 2607} 2608 2609void EnqueueVisitor::VisitOMPTargetDirective(const OMPTargetDirective *D) { 2610 VisitOMPExecutableDirective(D); 2611} 2612 2613void EnqueueVisitor::VisitOMPTargetDataDirective(const 2614 OMPTargetDataDirective *D) { 2615 VisitOMPExecutableDirective(D); 2616} 2617 2618void EnqueueVisitor::VisitOMPTeamsDirective(const OMPTeamsDirective *D) { 2619 VisitOMPExecutableDirective(D); 2620} 2621 2622void EnqueueVisitor::VisitOMPCancellationPointDirective( 2623 const OMPCancellationPointDirective *D) { 2624 VisitOMPExecutableDirective(D); 2625} 2626 2627void EnqueueVisitor::VisitOMPCancelDirective(const OMPCancelDirective *D) { 2628 VisitOMPExecutableDirective(D); 2629} 2630 2631void EnqueueVisitor::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D) { 2632 VisitOMPLoopDirective(D); 2633} 2634 2635void EnqueueVisitor::VisitOMPTaskLoopSimdDirective( 2636 const OMPTaskLoopSimdDirective *D) { 2637 VisitOMPLoopDirective(D); 2638} 2639 2640void EnqueueVisitor::VisitOMPDistributeDirective( 2641 const OMPDistributeDirective *D) { 2642 VisitOMPLoopDirective(D); 2643} 2644 2645void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) { 2646 EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S); 2647} 2648 2649bool CursorVisitor::IsInRegionOfInterest(CXCursor C) { 2650 if (RegionOfInterest.isValid()) { 2651 SourceRange Range = getRawCursorExtent(C); 2652 if (Range.isInvalid() || CompareRegionOfInterest(Range)) 2653 return false; 2654 } 2655 return true; 2656} 2657 2658bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) { 2659 while (!WL.empty()) { 2660 // Dequeue the worklist item. 2661 VisitorJob LI = WL.pop_back_val(); 2662 2663 // Set the Parent field, then back to its old value once we're done. 2664 SetParentRAII SetParent(Parent, StmtParent, LI.getParent()); 2665 2666 switch (LI.getKind()) { 2667 case VisitorJob::DeclVisitKind: { 2668 const Decl *D = cast<DeclVisit>(&LI)->get(); 2669 if (!D) 2670 continue; 2671 2672 // For now, perform default visitation for Decls. 2673 if (Visit(MakeCXCursor(D, TU, RegionOfInterest, 2674 cast<DeclVisit>(&LI)->isFirst()))) 2675 return true; 2676 2677 continue; 2678 } 2679 case VisitorJob::ExplicitTemplateArgsVisitKind: { 2680 const ASTTemplateArgumentListInfo *ArgList = 2681 cast<ExplicitTemplateArgsVisit>(&LI)->get(); 2682 for (const TemplateArgumentLoc *Arg = ArgList->getTemplateArgs(), 2683 *ArgEnd = Arg + ArgList->NumTemplateArgs; 2684 Arg != ArgEnd; ++Arg) { 2685 if (VisitTemplateArgumentLoc(*Arg)) 2686 return true; 2687 } 2688 continue; 2689 } 2690 case VisitorJob::TypeLocVisitKind: { 2691 // Perform default visitation for TypeLocs. 2692 if (Visit(cast<TypeLocVisit>(&LI)->get())) 2693 return true; 2694 continue; 2695 } 2696 case VisitorJob::LabelRefVisitKind: { 2697 const LabelDecl *LS = cast<LabelRefVisit>(&LI)->get(); 2698 if (LabelStmt *stmt = LS->getStmt()) { 2699 if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(), 2700 TU))) { 2701 return true; 2702 } 2703 } 2704 continue; 2705 } 2706 2707 case VisitorJob::NestedNameSpecifierLocVisitKind: { 2708 NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI); 2709 if (VisitNestedNameSpecifierLoc(V->get())) 2710 return true; 2711 continue; 2712 } 2713 2714 case VisitorJob::DeclarationNameInfoVisitKind: { 2715 if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI) 2716 ->get())) 2717 return true; 2718 continue; 2719 } 2720 case VisitorJob::MemberRefVisitKind: { 2721 MemberRefVisit *V = cast<MemberRefVisit>(&LI); 2722 if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU))) 2723 return true; 2724 continue; 2725 } 2726 case VisitorJob::StmtVisitKind: { 2727 const Stmt *S = cast<StmtVisit>(&LI)->get(); 2728 if (!S) 2729 continue; 2730 2731 // Update the current cursor. 2732 CXCursor Cursor = MakeCXCursor(S, StmtParent, TU, RegionOfInterest); 2733 if (!IsInRegionOfInterest(Cursor)) 2734 continue; 2735 switch (Visitor(Cursor, Parent, ClientData)) { 2736 case CXChildVisit_Break: return true; 2737 case CXChildVisit_Continue: break; 2738 case CXChildVisit_Recurse: 2739 if (PostChildrenVisitor) 2740 WL.push_back(PostChildrenVisit(nullptr, Cursor)); 2741 EnqueueWorkList(WL, S); 2742 break; 2743 } 2744 continue; 2745 } 2746 case VisitorJob::MemberExprPartsKind: { 2747 // Handle the other pieces in the MemberExpr besides the base. 2748 const MemberExpr *M = cast<MemberExprParts>(&LI)->get(); 2749 2750 // Visit the nested-name-specifier 2751 if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc()) 2752 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2753 return true; 2754 2755 // Visit the declaration name. 2756 if (VisitDeclarationNameInfo(M->getMemberNameInfo())) 2757 return true; 2758 2759 // Visit the explicitly-specified template arguments, if any. 2760 if (M->hasExplicitTemplateArgs()) { 2761 for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(), 2762 *ArgEnd = Arg + M->getNumTemplateArgs(); 2763 Arg != ArgEnd; ++Arg) { 2764 if (VisitTemplateArgumentLoc(*Arg)) 2765 return true; 2766 } 2767 } 2768 continue; 2769 } 2770 case VisitorJob::DeclRefExprPartsKind: { 2771 const DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get(); 2772 // Visit nested-name-specifier, if present. 2773 if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc()) 2774 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2775 return true; 2776 // Visit declaration name. 2777 if (VisitDeclarationNameInfo(DR->getNameInfo())) 2778 return true; 2779 continue; 2780 } 2781 case VisitorJob::OverloadExprPartsKind: { 2782 const OverloadExpr *O = cast<OverloadExprParts>(&LI)->get(); 2783 // Visit the nested-name-specifier. 2784 if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc()) 2785 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2786 return true; 2787 // Visit the declaration name. 2788 if (VisitDeclarationNameInfo(O->getNameInfo())) 2789 return true; 2790 // Visit the overloaded declaration reference. 2791 if (Visit(MakeCursorOverloadedDeclRef(O, TU))) 2792 return true; 2793 continue; 2794 } 2795 case VisitorJob::SizeOfPackExprPartsKind: { 2796 const SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get(); 2797 NamedDecl *Pack = E->getPack(); 2798 if (isa<TemplateTypeParmDecl>(Pack)) { 2799 if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack), 2800 E->getPackLoc(), TU))) 2801 return true; 2802 2803 continue; 2804 } 2805 2806 if (isa<TemplateTemplateParmDecl>(Pack)) { 2807 if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack), 2808 E->getPackLoc(), TU))) 2809 return true; 2810 2811 continue; 2812 } 2813 2814 // Non-type template parameter packs and function parameter packs are 2815 // treated like DeclRefExpr cursors. 2816 continue; 2817 } 2818 2819 case VisitorJob::LambdaExprPartsKind: { 2820 // Visit captures. 2821 const LambdaExpr *E = cast<LambdaExprParts>(&LI)->get(); 2822 for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(), 2823 CEnd = E->explicit_capture_end(); 2824 C != CEnd; ++C) { 2825 // FIXME: Lambda init-captures. 2826 if (!C->capturesVariable()) 2827 continue; 2828 2829 if (Visit(MakeCursorVariableRef(C->getCapturedVar(), 2830 C->getLocation(), 2831 TU))) 2832 return true; 2833 } 2834 2835 // Visit parameters and return type, if present. 2836 if (E->hasExplicitParameters() || E->hasExplicitResultType()) { 2837 TypeLoc TL = E->getCallOperator()->getTypeSourceInfo()->getTypeLoc(); 2838 if (E->hasExplicitParameters() && E->hasExplicitResultType()) { 2839 // Visit the whole type. 2840 if (Visit(TL)) 2841 return true; 2842 } else if (FunctionProtoTypeLoc Proto = 2843 TL.getAs<FunctionProtoTypeLoc>()) { 2844 if (E->hasExplicitParameters()) { 2845 // Visit parameters. 2846 for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I) 2847 if (Visit(MakeCXCursor(Proto.getParam(I), TU))) 2848 return true; 2849 } else { 2850 // Visit result type. 2851 if (Visit(Proto.getReturnLoc())) 2852 return true; 2853 } 2854 } 2855 } 2856 break; 2857 } 2858 2859 case VisitorJob::PostChildrenVisitKind: 2860 if (PostChildrenVisitor(Parent, ClientData)) 2861 return true; 2862 break; 2863 } 2864 } 2865 return false; 2866} 2867 2868bool CursorVisitor::Visit(const Stmt *S) { 2869 VisitorWorkList *WL = nullptr; 2870 if (!WorkListFreeList.empty()) { 2871 WL = WorkListFreeList.back(); 2872 WL->clear(); 2873 WorkListFreeList.pop_back(); 2874 } 2875 else { 2876 WL = new VisitorWorkList(); 2877 WorkListCache.push_back(WL); 2878 } 2879 EnqueueWorkList(*WL, S); 2880 bool result = RunVisitorWorkList(*WL); 2881 WorkListFreeList.push_back(WL); 2882 return result; 2883} 2884 2885namespace { 2886typedef SmallVector<SourceRange, 4> RefNamePieces; 2887RefNamePieces 2888buildPieces(unsigned NameFlags, bool IsMemberRefExpr, 2889 const DeclarationNameInfo &NI, SourceRange QLoc, 2890 const ASTTemplateArgumentListInfo *TemplateArgs = nullptr) { 2891 const bool WantQualifier = NameFlags & CXNameRange_WantQualifier; 2892 const bool WantTemplateArgs = NameFlags & CXNameRange_WantTemplateArgs; 2893 const bool WantSinglePiece = NameFlags & CXNameRange_WantSinglePiece; 2894 2895 const DeclarationName::NameKind Kind = NI.getName().getNameKind(); 2896 2897 RefNamePieces Pieces; 2898 2899 if (WantQualifier && QLoc.isValid()) 2900 Pieces.push_back(QLoc); 2901 2902 if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr) 2903 Pieces.push_back(NI.getLoc()); 2904 2905 if (WantTemplateArgs && TemplateArgs) 2906 Pieces.push_back(SourceRange(TemplateArgs->LAngleLoc, 2907 TemplateArgs->RAngleLoc)); 2908 2909 if (Kind == DeclarationName::CXXOperatorName) { 2910 Pieces.push_back(SourceLocation::getFromRawEncoding( 2911 NI.getInfo().CXXOperatorName.BeginOpNameLoc)); 2912 Pieces.push_back(SourceLocation::getFromRawEncoding( 2913 NI.getInfo().CXXOperatorName.EndOpNameLoc)); 2914 } 2915 2916 if (WantSinglePiece) { 2917 SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd()); 2918 Pieces.clear(); 2919 Pieces.push_back(R); 2920 } 2921 2922 return Pieces; 2923} 2924} 2925 2926//===----------------------------------------------------------------------===// 2927// Misc. API hooks. 2928//===----------------------------------------------------------------------===// 2929 2930static void fatal_error_handler(void *user_data, const std::string& reason, 2931 bool gen_crash_diag) { 2932 // Write the result out to stderr avoiding errs() because raw_ostreams can 2933 // call report_fatal_error. 2934 fprintf(stderr, "LIBCLANG FATAL ERROR: %s\n", reason.c_str()); 2935 ::abort(); 2936} 2937 2938namespace { 2939struct RegisterFatalErrorHandler { 2940 RegisterFatalErrorHandler() { 2941 llvm::install_fatal_error_handler(fatal_error_handler, nullptr); 2942 } 2943}; 2944} 2945 2946static llvm::ManagedStatic<RegisterFatalErrorHandler> RegisterFatalErrorHandlerOnce; 2947 2948extern "C" { 2949CXIndex clang_createIndex(int excludeDeclarationsFromPCH, 2950 int displayDiagnostics) { 2951 // We use crash recovery to make some of our APIs more reliable, implicitly 2952 // enable it. 2953 if (!getenv("LIBCLANG_DISABLE_CRASH_RECOVERY")) 2954 llvm::CrashRecoveryContext::Enable(); 2955 2956 // Look through the managed static to trigger construction of the managed 2957 // static which registers our fatal error handler. This ensures it is only 2958 // registered once. 2959 (void)*RegisterFatalErrorHandlerOnce; 2960 2961 // Initialize targets for clang module support. 2962 llvm::InitializeAllTargets(); 2963 llvm::InitializeAllTargetMCs(); 2964 llvm::InitializeAllAsmPrinters(); 2965 llvm::InitializeAllAsmParsers(); 2966 2967 CIndexer *CIdxr = new CIndexer(); 2968 2969 if (excludeDeclarationsFromPCH) 2970 CIdxr->setOnlyLocalDecls(); 2971 if (displayDiagnostics) 2972 CIdxr->setDisplayDiagnostics(); 2973 2974 if (getenv("LIBCLANG_BGPRIO_INDEX")) 2975 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() | 2976 CXGlobalOpt_ThreadBackgroundPriorityForIndexing); 2977 if (getenv("LIBCLANG_BGPRIO_EDIT")) 2978 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() | 2979 CXGlobalOpt_ThreadBackgroundPriorityForEditing); 2980 2981 return CIdxr; 2982} 2983 2984void clang_disposeIndex(CXIndex CIdx) { 2985 if (CIdx) 2986 delete static_cast<CIndexer *>(CIdx); 2987} 2988 2989void clang_CXIndex_setGlobalOptions(CXIndex CIdx, unsigned options) { 2990 if (CIdx) 2991 static_cast<CIndexer *>(CIdx)->setCXGlobalOptFlags(options); 2992} 2993 2994unsigned clang_CXIndex_getGlobalOptions(CXIndex CIdx) { 2995 if (CIdx) 2996 return static_cast<CIndexer *>(CIdx)->getCXGlobalOptFlags(); 2997 return 0; 2998} 2999 3000void clang_toggleCrashRecovery(unsigned isEnabled) { 3001 if (isEnabled) 3002 llvm::CrashRecoveryContext::Enable(); 3003 else 3004 llvm::CrashRecoveryContext::Disable(); 3005} 3006 3007CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx, 3008 const char *ast_filename) { 3009 CXTranslationUnit TU; 3010 enum CXErrorCode Result = 3011 clang_createTranslationUnit2(CIdx, ast_filename, &TU); 3012 (void)Result; 3013 assert((TU && Result == CXError_Success) || 3014 (!TU && Result != CXError_Success)); 3015 return TU; 3016} 3017 3018enum CXErrorCode clang_createTranslationUnit2(CXIndex CIdx, 3019 const char *ast_filename, 3020 CXTranslationUnit *out_TU) { 3021 if (out_TU) 3022 *out_TU = nullptr; 3023 3024 if (!CIdx || !ast_filename || !out_TU) 3025 return CXError_InvalidArguments; 3026 3027 LOG_FUNC_SECTION { 3028 *Log << ast_filename; 3029 } 3030 3031 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 3032 FileSystemOptions FileSystemOpts; 3033 3034 IntrusiveRefCntPtr<DiagnosticsEngine> Diags = 3035 CompilerInstance::createDiagnostics(new DiagnosticOptions()); 3036 std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile( 3037 ast_filename, CXXIdx->getPCHContainerOperations()->getRawReader(), Diags, 3038 FileSystemOpts, /*UseDebugInfo=*/false, 3039 CXXIdx->getOnlyLocalDecls(), None, 3040 /*CaptureDiagnostics=*/true, 3041 /*AllowPCHWithCompilerErrors=*/true, 3042 /*UserFilesAreVolatile=*/true); 3043 *out_TU = MakeCXTranslationUnit(CXXIdx, AU.release()); 3044 return *out_TU ? CXError_Success : CXError_Failure; 3045} 3046 3047unsigned clang_defaultEditingTranslationUnitOptions() { 3048 return CXTranslationUnit_PrecompiledPreamble | 3049 CXTranslationUnit_CacheCompletionResults; 3050} 3051 3052CXTranslationUnit 3053clang_createTranslationUnitFromSourceFile(CXIndex CIdx, 3054 const char *source_filename, 3055 int num_command_line_args, 3056 const char * const *command_line_args, 3057 unsigned num_unsaved_files, 3058 struct CXUnsavedFile *unsaved_files) { 3059 unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord; 3060 return clang_parseTranslationUnit(CIdx, source_filename, 3061 command_line_args, num_command_line_args, 3062 unsaved_files, num_unsaved_files, 3063 Options); 3064} 3065 3066static CXErrorCode 3067clang_parseTranslationUnit_Impl(CXIndex CIdx, const char *source_filename, 3068 const char *const *command_line_args, 3069 int num_command_line_args, 3070 ArrayRef<CXUnsavedFile> unsaved_files, 3071 unsigned options, CXTranslationUnit *out_TU) { 3072 // Set up the initial return values. 3073 if (out_TU) 3074 *out_TU = nullptr; 3075 3076 // Check arguments. 3077 if (!CIdx || !out_TU) 3078 return CXError_InvalidArguments; 3079 3080 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 3081 3082 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing)) 3083 setThreadBackgroundPriority(); 3084 3085 bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble; 3086 bool CreatePreambleOnFirstParse = 3087 options & CXTranslationUnit_CreatePreambleOnFirstParse; 3088 // FIXME: Add a flag for modules. 3089 TranslationUnitKind TUKind 3090 = (options & CXTranslationUnit_Incomplete)? TU_Prefix : TU_Complete; 3091 bool CacheCodeCompletionResults 3092 = options & CXTranslationUnit_CacheCompletionResults; 3093 bool IncludeBriefCommentsInCodeCompletion 3094 = options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion; 3095 bool SkipFunctionBodies = options & CXTranslationUnit_SkipFunctionBodies; 3096 bool ForSerialization = options & CXTranslationUnit_ForSerialization; 3097 3098 // Configure the diagnostics. 3099 IntrusiveRefCntPtr<DiagnosticsEngine> 3100 Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions)); 3101 3102 // Recover resources if we crash before exiting this function. 3103 llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine, 3104 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> > 3105 DiagCleanup(Diags.get()); 3106 3107 std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles( 3108 new std::vector<ASTUnit::RemappedFile>()); 3109 3110 // Recover resources if we crash before exiting this function. 3111 llvm::CrashRecoveryContextCleanupRegistrar< 3112 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get()); 3113 3114 for (auto &UF : unsaved_files) { 3115 std::unique_ptr<llvm::MemoryBuffer> MB = 3116 llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename); 3117 RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release())); 3118 } 3119 3120 std::unique_ptr<std::vector<const char *>> Args( 3121 new std::vector<const char *>()); 3122 3123 // Recover resources if we crash before exiting this method. 3124 llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> > 3125 ArgsCleanup(Args.get()); 3126 3127 // Since the Clang C library is primarily used by batch tools dealing with 3128 // (often very broken) source code, where spell-checking can have a 3129 // significant negative impact on performance (particularly when 3130 // precompiled headers are involved), we disable it by default. 3131 // Only do this if we haven't found a spell-checking-related argument. 3132 bool FoundSpellCheckingArgument = false; 3133 for (int I = 0; I != num_command_line_args; ++I) { 3134 if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 || 3135 strcmp(command_line_args[I], "-fspell-checking") == 0) { 3136 FoundSpellCheckingArgument = true; 3137 break; 3138 } 3139 } 3140 Args->insert(Args->end(), command_line_args, 3141 command_line_args + num_command_line_args); 3142 3143 if (!FoundSpellCheckingArgument) 3144 Args->insert(Args->begin() + 1, "-fno-spell-checking"); 3145 3146 // The 'source_filename' argument is optional. If the caller does not 3147 // specify it then it is assumed that the source file is specified 3148 // in the actual argument list. 3149 // Put the source file after command_line_args otherwise if '-x' flag is 3150 // present it will be unused. 3151 if (source_filename) 3152 Args->push_back(source_filename); 3153 3154 // Do we need the detailed preprocessing record? 3155 if (options & CXTranslationUnit_DetailedPreprocessingRecord) { 3156 Args->push_back("-Xclang"); 3157 Args->push_back("-detailed-preprocessing-record"); 3158 } 3159 3160 unsigned NumErrors = Diags->getClient()->getNumErrors(); 3161 std::unique_ptr<ASTUnit> ErrUnit; 3162 // Unless the user specified that they want the preamble on the first parse 3163 // set it up to be created on the first reparse. This makes the first parse 3164 // faster, trading for a slower (first) reparse. 3165 unsigned PrecompilePreambleAfterNParses = 3166 !PrecompilePreamble ? 0 : 2 - CreatePreambleOnFirstParse; 3167 std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine( 3168 Args->data(), Args->data() + Args->size(), 3169 CXXIdx->getPCHContainerOperations(), Diags, 3170 CXXIdx->getClangResourcesPath(), CXXIdx->getOnlyLocalDecls(), 3171 /*CaptureDiagnostics=*/true, *RemappedFiles.get(), 3172 /*RemappedFilesKeepOriginalName=*/true, PrecompilePreambleAfterNParses, 3173 TUKind, CacheCodeCompletionResults, IncludeBriefCommentsInCodeCompletion, 3174 /*AllowPCHWithCompilerErrors=*/true, SkipFunctionBodies, 3175 /*UserFilesAreVolatile=*/true, ForSerialization, 3176 CXXIdx->getPCHContainerOperations()->getRawReader().getFormat(), 3177 &ErrUnit)); 3178 3179 // Early failures in LoadFromCommandLine may return with ErrUnit unset. 3180 if (!Unit && !ErrUnit) 3181 return CXError_ASTReadError; 3182 3183 if (NumErrors != Diags->getClient()->getNumErrors()) { 3184 // Make sure to check that 'Unit' is non-NULL. 3185 if (CXXIdx->getDisplayDiagnostics()) 3186 printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get()); 3187 } 3188 3189 if (isASTReadError(Unit ? Unit.get() : ErrUnit.get())) 3190 return CXError_ASTReadError; 3191 3192 *out_TU = MakeCXTranslationUnit(CXXIdx, Unit.release()); 3193 return *out_TU ? CXError_Success : CXError_Failure; 3194} 3195 3196CXTranslationUnit 3197clang_parseTranslationUnit(CXIndex CIdx, 3198 const char *source_filename, 3199 const char *const *command_line_args, 3200 int num_command_line_args, 3201 struct CXUnsavedFile *unsaved_files, 3202 unsigned num_unsaved_files, 3203 unsigned options) { 3204 CXTranslationUnit TU; 3205 enum CXErrorCode Result = clang_parseTranslationUnit2( 3206 CIdx, source_filename, command_line_args, num_command_line_args, 3207 unsaved_files, num_unsaved_files, options, &TU); 3208 (void)Result; 3209 assert((TU && Result == CXError_Success) || 3210 (!TU && Result != CXError_Success)); 3211 return TU; 3212} 3213 3214enum CXErrorCode clang_parseTranslationUnit2( 3215 CXIndex CIdx, const char *source_filename, 3216 const char *const *command_line_args, int num_command_line_args, 3217 struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, 3218 unsigned options, CXTranslationUnit *out_TU) { 3219 SmallVector<const char *, 4> Args; 3220 Args.push_back("clang"); 3221 Args.append(command_line_args, command_line_args + num_command_line_args); 3222 return clang_parseTranslationUnit2FullArgv( 3223 CIdx, source_filename, Args.data(), Args.size(), unsaved_files, 3224 num_unsaved_files, options, out_TU); 3225} 3226 3227enum CXErrorCode clang_parseTranslationUnit2FullArgv( 3228 CXIndex CIdx, const char *source_filename, 3229 const char *const *command_line_args, int num_command_line_args, 3230 struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, 3231 unsigned options, CXTranslationUnit *out_TU) { 3232 LOG_FUNC_SECTION { 3233 *Log << source_filename << ": "; 3234 for (int i = 0; i != num_command_line_args; ++i) 3235 *Log << command_line_args[i] << " "; 3236 } 3237 3238 if (num_unsaved_files && !unsaved_files) 3239 return CXError_InvalidArguments; 3240 3241 CXErrorCode result = CXError_Failure; 3242 auto ParseTranslationUnitImpl = [=, &result] { 3243 result = clang_parseTranslationUnit_Impl( 3244 CIdx, source_filename, command_line_args, num_command_line_args, 3245 llvm::makeArrayRef(unsaved_files, num_unsaved_files), options, out_TU); 3246 }; 3247 llvm::CrashRecoveryContext CRC; 3248 3249 if (!RunSafely(CRC, ParseTranslationUnitImpl)) { 3250 fprintf(stderr, "libclang: crash detected during parsing: {\n"); 3251 fprintf(stderr, " 'source_filename' : '%s'\n", source_filename); 3252 fprintf(stderr, " 'command_line_args' : ["); 3253 for (int i = 0; i != num_command_line_args; ++i) { 3254 if (i) 3255 fprintf(stderr, ", "); 3256 fprintf(stderr, "'%s'", command_line_args[i]); 3257 } 3258 fprintf(stderr, "],\n"); 3259 fprintf(stderr, " 'unsaved_files' : ["); 3260 for (unsigned i = 0; i != num_unsaved_files; ++i) { 3261 if (i) 3262 fprintf(stderr, ", "); 3263 fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename, 3264 unsaved_files[i].Length); 3265 } 3266 fprintf(stderr, "],\n"); 3267 fprintf(stderr, " 'options' : %d,\n", options); 3268 fprintf(stderr, "}\n"); 3269 3270 return CXError_Crashed; 3271 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) { 3272 if (CXTranslationUnit *TU = out_TU) 3273 PrintLibclangResourceUsage(*TU); 3274 } 3275 3276 return result; 3277} 3278 3279unsigned clang_defaultSaveOptions(CXTranslationUnit TU) { 3280 return CXSaveTranslationUnit_None; 3281} 3282 3283static CXSaveError clang_saveTranslationUnit_Impl(CXTranslationUnit TU, 3284 const char *FileName, 3285 unsigned options) { 3286 CIndexer *CXXIdx = TU->CIdx; 3287 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing)) 3288 setThreadBackgroundPriority(); 3289 3290 bool hadError = cxtu::getASTUnit(TU)->Save(FileName); 3291 return hadError ? CXSaveError_Unknown : CXSaveError_None; 3292} 3293 3294int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName, 3295 unsigned options) { 3296 LOG_FUNC_SECTION { 3297 *Log << TU << ' ' << FileName; 3298 } 3299 3300 if (isNotUsableTU(TU)) { 3301 LOG_BAD_TU(TU); 3302 return CXSaveError_InvalidTU; 3303 } 3304 3305 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 3306 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 3307 if (!CXXUnit->hasSema()) 3308 return CXSaveError_InvalidTU; 3309 3310 CXSaveError result; 3311 auto SaveTranslationUnitImpl = [=, &result]() { 3312 result = clang_saveTranslationUnit_Impl(TU, FileName, options); 3313 }; 3314 3315 if (!CXXUnit->getDiagnostics().hasUnrecoverableErrorOccurred() || 3316 getenv("LIBCLANG_NOTHREADS")) { 3317 SaveTranslationUnitImpl(); 3318 3319 if (getenv("LIBCLANG_RESOURCE_USAGE")) 3320 PrintLibclangResourceUsage(TU); 3321 3322 return result; 3323 } 3324 3325 // We have an AST that has invalid nodes due to compiler errors. 3326 // Use a crash recovery thread for protection. 3327 3328 llvm::CrashRecoveryContext CRC; 3329 3330 if (!RunSafely(CRC, SaveTranslationUnitImpl)) { 3331 fprintf(stderr, "libclang: crash detected during AST saving: {\n"); 3332 fprintf(stderr, " 'filename' : '%s'\n", FileName); 3333 fprintf(stderr, " 'options' : %d,\n", options); 3334 fprintf(stderr, "}\n"); 3335 3336 return CXSaveError_Unknown; 3337 3338 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) { 3339 PrintLibclangResourceUsage(TU); 3340 } 3341 3342 return result; 3343} 3344 3345void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) { 3346 if (CTUnit) { 3347 // If the translation unit has been marked as unsafe to free, just discard 3348 // it. 3349 ASTUnit *Unit = cxtu::getASTUnit(CTUnit); 3350 if (Unit && Unit->isUnsafeToFree()) 3351 return; 3352 3353 delete cxtu::getASTUnit(CTUnit); 3354 delete CTUnit->StringPool; 3355 delete static_cast<CXDiagnosticSetImpl *>(CTUnit->Diagnostics); 3356 disposeOverridenCXCursorsPool(CTUnit->OverridenCursorsPool); 3357 delete CTUnit->CommentToXML; 3358 delete CTUnit; 3359 } 3360} 3361 3362unsigned clang_defaultReparseOptions(CXTranslationUnit TU) { 3363 return CXReparse_None; 3364} 3365 3366static CXErrorCode 3367clang_reparseTranslationUnit_Impl(CXTranslationUnit TU, 3368 ArrayRef<CXUnsavedFile> unsaved_files, 3369 unsigned options) { 3370 // Check arguments. 3371 if (isNotUsableTU(TU)) { 3372 LOG_BAD_TU(TU); 3373 return CXError_InvalidArguments; 3374 } 3375 3376 // Reset the associated diagnostics. 3377 delete static_cast<CXDiagnosticSetImpl*>(TU->Diagnostics); 3378 TU->Diagnostics = nullptr; 3379 3380 CIndexer *CXXIdx = TU->CIdx; 3381 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 3382 setThreadBackgroundPriority(); 3383 3384 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 3385 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 3386 3387 std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles( 3388 new std::vector<ASTUnit::RemappedFile>()); 3389 3390 // Recover resources if we crash before exiting this function. 3391 llvm::CrashRecoveryContextCleanupRegistrar< 3392 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get()); 3393 3394 for (auto &UF : unsaved_files) { 3395 std::unique_ptr<llvm::MemoryBuffer> MB = 3396 llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename); 3397 RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release())); 3398 } 3399 3400 if (!CXXUnit->Reparse(CXXIdx->getPCHContainerOperations(), 3401 *RemappedFiles.get())) 3402 return CXError_Success; 3403 if (isASTReadError(CXXUnit)) 3404 return CXError_ASTReadError; 3405 return CXError_Failure; 3406} 3407 3408int clang_reparseTranslationUnit(CXTranslationUnit TU, 3409 unsigned num_unsaved_files, 3410 struct CXUnsavedFile *unsaved_files, 3411 unsigned options) { 3412 LOG_FUNC_SECTION { 3413 *Log << TU; 3414 } 3415 3416 if (num_unsaved_files && !unsaved_files) 3417 return CXError_InvalidArguments; 3418 3419 CXErrorCode result; 3420 auto ReparseTranslationUnitImpl = [=, &result]() { 3421 result = clang_reparseTranslationUnit_Impl( 3422 TU, llvm::makeArrayRef(unsaved_files, num_unsaved_files), options); 3423 }; 3424 3425 if (getenv("LIBCLANG_NOTHREADS")) { 3426 ReparseTranslationUnitImpl(); 3427 return result; 3428 } 3429 3430 llvm::CrashRecoveryContext CRC; 3431 3432 if (!RunSafely(CRC, ReparseTranslationUnitImpl)) { 3433 fprintf(stderr, "libclang: crash detected during reparsing\n"); 3434 cxtu::getASTUnit(TU)->setUnsafeToFree(true); 3435 return CXError_Crashed; 3436 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) 3437 PrintLibclangResourceUsage(TU); 3438 3439 return result; 3440} 3441 3442 3443CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) { 3444 if (isNotUsableTU(CTUnit)) { 3445 LOG_BAD_TU(CTUnit); 3446 return cxstring::createEmpty(); 3447 } 3448 3449 ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit); 3450 return cxstring::createDup(CXXUnit->getOriginalSourceFileName()); 3451} 3452 3453CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) { 3454 if (isNotUsableTU(TU)) { 3455 LOG_BAD_TU(TU); 3456 return clang_getNullCursor(); 3457 } 3458 3459 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 3460 return MakeCXCursor(CXXUnit->getASTContext().getTranslationUnitDecl(), TU); 3461} 3462 3463} // end: extern "C" 3464 3465//===----------------------------------------------------------------------===// 3466// CXFile Operations. 3467//===----------------------------------------------------------------------===// 3468 3469extern "C" { 3470CXString clang_getFileName(CXFile SFile) { 3471 if (!SFile) 3472 return cxstring::createNull(); 3473 3474 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 3475 return cxstring::createRef(FEnt->getName()); 3476} 3477 3478time_t clang_getFileTime(CXFile SFile) { 3479 if (!SFile) 3480 return 0; 3481 3482 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 3483 return FEnt->getModificationTime(); 3484} 3485 3486CXFile clang_getFile(CXTranslationUnit TU, const char *file_name) { 3487 if (isNotUsableTU(TU)) { 3488 LOG_BAD_TU(TU); 3489 return nullptr; 3490 } 3491 3492 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 3493 3494 FileManager &FMgr = CXXUnit->getFileManager(); 3495 return const_cast<FileEntry *>(FMgr.getFile(file_name)); 3496} 3497 3498unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit TU, 3499 CXFile file) { 3500 if (isNotUsableTU(TU)) { 3501 LOG_BAD_TU(TU); 3502 return 0; 3503 } 3504 3505 if (!file) 3506 return 0; 3507 3508 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 3509 FileEntry *FEnt = static_cast<FileEntry *>(file); 3510 return CXXUnit->getPreprocessor().getHeaderSearchInfo() 3511 .isFileMultipleIncludeGuarded(FEnt); 3512} 3513 3514int clang_getFileUniqueID(CXFile file, CXFileUniqueID *outID) { 3515 if (!file || !outID) 3516 return 1; 3517 3518 FileEntry *FEnt = static_cast<FileEntry *>(file); 3519 const llvm::sys::fs::UniqueID &ID = FEnt->getUniqueID(); 3520 outID->data[0] = ID.getDevice(); 3521 outID->data[1] = ID.getFile(); 3522 outID->data[2] = FEnt->getModificationTime(); 3523 return 0; 3524} 3525 3526int clang_File_isEqual(CXFile file1, CXFile file2) { 3527 if (file1 == file2) 3528 return true; 3529 3530 if (!file1 || !file2) 3531 return false; 3532 3533 FileEntry *FEnt1 = static_cast<FileEntry *>(file1); 3534 FileEntry *FEnt2 = static_cast<FileEntry *>(file2); 3535 return FEnt1->getUniqueID() == FEnt2->getUniqueID(); 3536} 3537 3538} // end: extern "C" 3539 3540//===----------------------------------------------------------------------===// 3541// CXCursor Operations. 3542//===----------------------------------------------------------------------===// 3543 3544static const Decl *getDeclFromExpr(const Stmt *E) { 3545 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 3546 return getDeclFromExpr(CE->getSubExpr()); 3547 3548 if (const DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E)) 3549 return RefExpr->getDecl(); 3550 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) 3551 return ME->getMemberDecl(); 3552 if (const ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E)) 3553 return RE->getDecl(); 3554 if (const ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E)) { 3555 if (PRE->isExplicitProperty()) 3556 return PRE->getExplicitProperty(); 3557 // It could be messaging both getter and setter as in: 3558 // ++myobj.myprop; 3559 // in which case prefer to associate the setter since it is less obvious 3560 // from inspecting the source that the setter is going to get called. 3561 if (PRE->isMessagingSetter()) 3562 return PRE->getImplicitPropertySetter(); 3563 return PRE->getImplicitPropertyGetter(); 3564 } 3565 if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) 3566 return getDeclFromExpr(POE->getSyntacticForm()); 3567 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) 3568 if (Expr *Src = OVE->getSourceExpr()) 3569 return getDeclFromExpr(Src); 3570 3571 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) 3572 return getDeclFromExpr(CE->getCallee()); 3573 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E)) 3574 if (!CE->isElidable()) 3575 return CE->getConstructor(); 3576 if (const ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E)) 3577 return OME->getMethodDecl(); 3578 3579 if (const ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E)) 3580 return PE->getProtocol(); 3581 if (const SubstNonTypeTemplateParmPackExpr *NTTP 3582 = dyn_cast<SubstNonTypeTemplateParmPackExpr>(E)) 3583 return NTTP->getParameterPack(); 3584 if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 3585 if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) || 3586 isa<ParmVarDecl>(SizeOfPack->getPack())) 3587 return SizeOfPack->getPack(); 3588 3589 return nullptr; 3590} 3591 3592static SourceLocation getLocationFromExpr(const Expr *E) { 3593 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 3594 return getLocationFromExpr(CE->getSubExpr()); 3595 3596 if (const ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E)) 3597 return /*FIXME:*/Msg->getLeftLoc(); 3598 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 3599 return DRE->getLocation(); 3600 if (const MemberExpr *Member = dyn_cast<MemberExpr>(E)) 3601 return Member->getMemberLoc(); 3602 if (const ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E)) 3603 return Ivar->getLocation(); 3604 if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 3605 return SizeOfPack->getPackLoc(); 3606 if (const ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E)) 3607 return PropRef->getLocation(); 3608 3609 return E->getLocStart(); 3610} 3611 3612static std::string getMangledStructor(std::unique_ptr<MangleContext> &M, 3613 std::unique_ptr<llvm::DataLayout> &DL, 3614 const NamedDecl *ND, 3615 unsigned StructorType) { 3616 std::string FrontendBuf; 3617 llvm::raw_string_ostream FOS(FrontendBuf); 3618 3619 if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND)) 3620 M->mangleCXXCtor(CD, static_cast<CXXCtorType>(StructorType), FOS); 3621 else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND)) 3622 M->mangleCXXDtor(DD, static_cast<CXXDtorType>(StructorType), FOS); 3623 3624 std::string BackendBuf; 3625 llvm::raw_string_ostream BOS(BackendBuf); 3626 3627 llvm::Mangler::getNameWithPrefix(BOS, llvm::Twine(FOS.str()), *DL); 3628 3629 return BOS.str(); 3630} 3631 3632extern "C" { 3633 3634unsigned clang_visitChildren(CXCursor parent, 3635 CXCursorVisitor visitor, 3636 CXClientData client_data) { 3637 CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data, 3638 /*VisitPreprocessorLast=*/false); 3639 return CursorVis.VisitChildren(parent); 3640} 3641 3642#ifndef __has_feature 3643#define __has_feature(x) 0 3644#endif 3645#if __has_feature(blocks) 3646typedef enum CXChildVisitResult 3647 (^CXCursorVisitorBlock)(CXCursor cursor, CXCursor parent); 3648 3649static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 3650 CXClientData client_data) { 3651 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 3652 return block(cursor, parent); 3653} 3654#else 3655// If we are compiled with a compiler that doesn't have native blocks support, 3656// define and call the block manually, so the 3657typedef struct _CXChildVisitResult 3658{ 3659 void *isa; 3660 int flags; 3661 int reserved; 3662 enum CXChildVisitResult(*invoke)(struct _CXChildVisitResult*, CXCursor, 3663 CXCursor); 3664} *CXCursorVisitorBlock; 3665 3666static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 3667 CXClientData client_data) { 3668 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 3669 return block->invoke(block, cursor, parent); 3670} 3671#endif 3672 3673 3674unsigned clang_visitChildrenWithBlock(CXCursor parent, 3675 CXCursorVisitorBlock block) { 3676 return clang_visitChildren(parent, visitWithBlock, block); 3677} 3678 3679static CXString getDeclSpelling(const Decl *D) { 3680 if (!D) 3681 return cxstring::createEmpty(); 3682 3683 const NamedDecl *ND = dyn_cast<NamedDecl>(D); 3684 if (!ND) { 3685 if (const ObjCPropertyImplDecl *PropImpl = 3686 dyn_cast<ObjCPropertyImplDecl>(D)) 3687 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 3688 return cxstring::createDup(Property->getIdentifier()->getName()); 3689 3690 if (const ImportDecl *ImportD = dyn_cast<ImportDecl>(D)) 3691 if (Module *Mod = ImportD->getImportedModule()) 3692 return cxstring::createDup(Mod->getFullModuleName()); 3693 3694 return cxstring::createEmpty(); 3695 } 3696 3697 if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND)) 3698 return cxstring::createDup(OMD->getSelector().getAsString()); 3699 3700 if (const ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND)) 3701 // No, this isn't the same as the code below. getIdentifier() is non-virtual 3702 // and returns different names. NamedDecl returns the class name and 3703 // ObjCCategoryImplDecl returns the category name. 3704 return cxstring::createRef(CIMP->getIdentifier()->getNameStart()); 3705 3706 if (isa<UsingDirectiveDecl>(D)) 3707 return cxstring::createEmpty(); 3708 3709 SmallString<1024> S; 3710 llvm::raw_svector_ostream os(S); 3711 ND->printName(os); 3712 3713 return cxstring::createDup(os.str()); 3714} 3715 3716CXString clang_getCursorSpelling(CXCursor C) { 3717 if (clang_isTranslationUnit(C.kind)) 3718 return clang_getTranslationUnitSpelling(getCursorTU(C)); 3719 3720 if (clang_isReference(C.kind)) { 3721 switch (C.kind) { 3722 case CXCursor_ObjCSuperClassRef: { 3723 const ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first; 3724 return cxstring::createRef(Super->getIdentifier()->getNameStart()); 3725 } 3726 case CXCursor_ObjCClassRef: { 3727 const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first; 3728 return cxstring::createRef(Class->getIdentifier()->getNameStart()); 3729 } 3730 case CXCursor_ObjCProtocolRef: { 3731 const ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first; 3732 assert(OID && "getCursorSpelling(): Missing protocol decl"); 3733 return cxstring::createRef(OID->getIdentifier()->getNameStart()); 3734 } 3735 case CXCursor_CXXBaseSpecifier: { 3736 const CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C); 3737 return cxstring::createDup(B->getType().getAsString()); 3738 } 3739 case CXCursor_TypeRef: { 3740 const TypeDecl *Type = getCursorTypeRef(C).first; 3741 assert(Type && "Missing type decl"); 3742 3743 return cxstring::createDup(getCursorContext(C).getTypeDeclType(Type). 3744 getAsString()); 3745 } 3746 case CXCursor_TemplateRef: { 3747 const TemplateDecl *Template = getCursorTemplateRef(C).first; 3748 assert(Template && "Missing template decl"); 3749 3750 return cxstring::createDup(Template->getNameAsString()); 3751 } 3752 3753 case CXCursor_NamespaceRef: { 3754 const NamedDecl *NS = getCursorNamespaceRef(C).first; 3755 assert(NS && "Missing namespace decl"); 3756 3757 return cxstring::createDup(NS->getNameAsString()); 3758 } 3759 3760 case CXCursor_MemberRef: { 3761 const FieldDecl *Field = getCursorMemberRef(C).first; 3762 assert(Field && "Missing member decl"); 3763 3764 return cxstring::createDup(Field->getNameAsString()); 3765 } 3766 3767 case CXCursor_LabelRef: { 3768 const LabelStmt *Label = getCursorLabelRef(C).first; 3769 assert(Label && "Missing label"); 3770 3771 return cxstring::createRef(Label->getName()); 3772 } 3773 3774 case CXCursor_OverloadedDeclRef: { 3775 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 3776 if (const Decl *D = Storage.dyn_cast<const Decl *>()) { 3777 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) 3778 return cxstring::createDup(ND->getNameAsString()); 3779 return cxstring::createEmpty(); 3780 } 3781 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>()) 3782 return cxstring::createDup(E->getName().getAsString()); 3783 OverloadedTemplateStorage *Ovl 3784 = Storage.get<OverloadedTemplateStorage*>(); 3785 if (Ovl->size() == 0) 3786 return cxstring::createEmpty(); 3787 return cxstring::createDup((*Ovl->begin())->getNameAsString()); 3788 } 3789 3790 case CXCursor_VariableRef: { 3791 const VarDecl *Var = getCursorVariableRef(C).first; 3792 assert(Var && "Missing variable decl"); 3793 3794 return cxstring::createDup(Var->getNameAsString()); 3795 } 3796 3797 default: 3798 return cxstring::createRef("<not implemented>"); 3799 } 3800 } 3801 3802 if (clang_isExpression(C.kind)) { 3803 const Expr *E = getCursorExpr(C); 3804 3805 if (C.kind == CXCursor_ObjCStringLiteral || 3806 C.kind == CXCursor_StringLiteral) { 3807 const StringLiteral *SLit; 3808 if (const ObjCStringLiteral *OSL = dyn_cast<ObjCStringLiteral>(E)) { 3809 SLit = OSL->getString(); 3810 } else { 3811 SLit = cast<StringLiteral>(E); 3812 } 3813 SmallString<256> Buf; 3814 llvm::raw_svector_ostream OS(Buf); 3815 SLit->outputString(OS); 3816 return cxstring::createDup(OS.str()); 3817 } 3818 3819 const Decl *D = getDeclFromExpr(getCursorExpr(C)); 3820 if (D) 3821 return getDeclSpelling(D); 3822 return cxstring::createEmpty(); 3823 } 3824 3825 if (clang_isStatement(C.kind)) { 3826 const Stmt *S = getCursorStmt(C); 3827 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) 3828 return cxstring::createRef(Label->getName()); 3829 3830 return cxstring::createEmpty(); 3831 } 3832 3833 if (C.kind == CXCursor_MacroExpansion) 3834 return cxstring::createRef(getCursorMacroExpansion(C).getName() 3835 ->getNameStart()); 3836 3837 if (C.kind == CXCursor_MacroDefinition) 3838 return cxstring::createRef(getCursorMacroDefinition(C)->getName() 3839 ->getNameStart()); 3840 3841 if (C.kind == CXCursor_InclusionDirective) 3842 return cxstring::createDup(getCursorInclusionDirective(C)->getFileName()); 3843 3844 if (clang_isDeclaration(C.kind)) 3845 return getDeclSpelling(getCursorDecl(C)); 3846 3847 if (C.kind == CXCursor_AnnotateAttr) { 3848 const AnnotateAttr *AA = cast<AnnotateAttr>(cxcursor::getCursorAttr(C)); 3849 return cxstring::createDup(AA->getAnnotation()); 3850 } 3851 3852 if (C.kind == CXCursor_AsmLabelAttr) { 3853 const AsmLabelAttr *AA = cast<AsmLabelAttr>(cxcursor::getCursorAttr(C)); 3854 return cxstring::createDup(AA->getLabel()); 3855 } 3856 3857 if (C.kind == CXCursor_PackedAttr) { 3858 return cxstring::createRef("packed"); 3859 } 3860 3861 if (C.kind == CXCursor_VisibilityAttr) { 3862 const VisibilityAttr *AA = cast<VisibilityAttr>(cxcursor::getCursorAttr(C)); 3863 switch (AA->getVisibility()) { 3864 case VisibilityAttr::VisibilityType::Default: 3865 return cxstring::createRef("default"); 3866 case VisibilityAttr::VisibilityType::Hidden: 3867 return cxstring::createRef("hidden"); 3868 case VisibilityAttr::VisibilityType::Protected: 3869 return cxstring::createRef("protected"); 3870 } 3871 llvm_unreachable("unknown visibility type"); 3872 } 3873 3874 return cxstring::createEmpty(); 3875} 3876 3877CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C, 3878 unsigned pieceIndex, 3879 unsigned options) { 3880 if (clang_Cursor_isNull(C)) 3881 return clang_getNullRange(); 3882 3883 ASTContext &Ctx = getCursorContext(C); 3884 3885 if (clang_isStatement(C.kind)) { 3886 const Stmt *S = getCursorStmt(C); 3887 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) { 3888 if (pieceIndex > 0) 3889 return clang_getNullRange(); 3890 return cxloc::translateSourceRange(Ctx, Label->getIdentLoc()); 3891 } 3892 3893 return clang_getNullRange(); 3894 } 3895 3896 if (C.kind == CXCursor_ObjCMessageExpr) { 3897 if (const ObjCMessageExpr * 3898 ME = dyn_cast_or_null<ObjCMessageExpr>(getCursorExpr(C))) { 3899 if (pieceIndex >= ME->getNumSelectorLocs()) 3900 return clang_getNullRange(); 3901 return cxloc::translateSourceRange(Ctx, ME->getSelectorLoc(pieceIndex)); 3902 } 3903 } 3904 3905 if (C.kind == CXCursor_ObjCInstanceMethodDecl || 3906 C.kind == CXCursor_ObjCClassMethodDecl) { 3907 if (const ObjCMethodDecl * 3908 MD = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(C))) { 3909 if (pieceIndex >= MD->getNumSelectorLocs()) 3910 return clang_getNullRange(); 3911 return cxloc::translateSourceRange(Ctx, MD->getSelectorLoc(pieceIndex)); 3912 } 3913 } 3914 3915 if (C.kind == CXCursor_ObjCCategoryDecl || 3916 C.kind == CXCursor_ObjCCategoryImplDecl) { 3917 if (pieceIndex > 0) 3918 return clang_getNullRange(); 3919 if (const ObjCCategoryDecl * 3920 CD = dyn_cast_or_null<ObjCCategoryDecl>(getCursorDecl(C))) 3921 return cxloc::translateSourceRange(Ctx, CD->getCategoryNameLoc()); 3922 if (const ObjCCategoryImplDecl * 3923 CID = dyn_cast_or_null<ObjCCategoryImplDecl>(getCursorDecl(C))) 3924 return cxloc::translateSourceRange(Ctx, CID->getCategoryNameLoc()); 3925 } 3926 3927 if (C.kind == CXCursor_ModuleImportDecl) { 3928 if (pieceIndex > 0) 3929 return clang_getNullRange(); 3930 if (const ImportDecl *ImportD = 3931 dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) { 3932 ArrayRef<SourceLocation> Locs = ImportD->getIdentifierLocs(); 3933 if (!Locs.empty()) 3934 return cxloc::translateSourceRange(Ctx, 3935 SourceRange(Locs.front(), Locs.back())); 3936 } 3937 return clang_getNullRange(); 3938 } 3939 3940 if (C.kind == CXCursor_CXXMethod || C.kind == CXCursor_Destructor || 3941 C.kind == CXCursor_ConversionFunction) { 3942 if (pieceIndex > 0) 3943 return clang_getNullRange(); 3944 if (const FunctionDecl *FD = 3945 dyn_cast_or_null<FunctionDecl>(getCursorDecl(C))) { 3946 DeclarationNameInfo FunctionName = FD->getNameInfo(); 3947 return cxloc::translateSourceRange(Ctx, FunctionName.getSourceRange()); 3948 } 3949 return clang_getNullRange(); 3950 } 3951 3952 // FIXME: A CXCursor_InclusionDirective should give the location of the 3953 // filename, but we don't keep track of this. 3954 3955 // FIXME: A CXCursor_AnnotateAttr should give the location of the annotation 3956 // but we don't keep track of this. 3957 3958 // FIXME: A CXCursor_AsmLabelAttr should give the location of the label 3959 // but we don't keep track of this. 3960 3961 // Default handling, give the location of the cursor. 3962 3963 if (pieceIndex > 0) 3964 return clang_getNullRange(); 3965 3966 CXSourceLocation CXLoc = clang_getCursorLocation(C); 3967 SourceLocation Loc = cxloc::translateSourceLocation(CXLoc); 3968 return cxloc::translateSourceRange(Ctx, Loc); 3969} 3970 3971CXString clang_Cursor_getMangling(CXCursor C) { 3972 if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind)) 3973 return cxstring::createEmpty(); 3974 3975 // Mangling only works for functions and variables. 3976 const Decl *D = getCursorDecl(C); 3977 if (!D || !(isa<FunctionDecl>(D) || isa<VarDecl>(D))) 3978 return cxstring::createEmpty(); 3979 3980 // First apply frontend mangling. 3981 const NamedDecl *ND = cast<NamedDecl>(D); 3982 ASTContext &Ctx = ND->getASTContext(); 3983 std::unique_ptr<MangleContext> MC(Ctx.createMangleContext()); 3984 3985 std::string FrontendBuf; 3986 llvm::raw_string_ostream FrontendBufOS(FrontendBuf); 3987 if (MC->shouldMangleDeclName(ND)) { 3988 MC->mangleName(ND, FrontendBufOS); 3989 } else { 3990 ND->printName(FrontendBufOS); 3991 } 3992 3993 // Now apply backend mangling. 3994 std::unique_ptr<llvm::DataLayout> DL( 3995 new llvm::DataLayout(Ctx.getTargetInfo().getDataLayoutString())); 3996 3997 std::string FinalBuf; 3998 llvm::raw_string_ostream FinalBufOS(FinalBuf); 3999 llvm::Mangler::getNameWithPrefix(FinalBufOS, llvm::Twine(FrontendBufOS.str()), 4000 *DL); 4001 4002 return cxstring::createDup(FinalBufOS.str()); 4003} 4004 4005CXStringSet *clang_Cursor_getCXXManglings(CXCursor C) { 4006 if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind)) 4007 return nullptr; 4008 4009 const Decl *D = getCursorDecl(C); 4010 if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D))) 4011 return nullptr; 4012 4013 const NamedDecl *ND = cast<NamedDecl>(D); 4014 4015 ASTContext &Ctx = ND->getASTContext(); 4016 std::unique_ptr<MangleContext> M(Ctx.createMangleContext()); 4017 std::unique_ptr<llvm::DataLayout> DL( 4018 new llvm::DataLayout(Ctx.getTargetInfo().getDataLayoutString())); 4019 4020 std::vector<std::string> Manglings; 4021 4022 auto hasDefaultCXXMethodCC = [](ASTContext &C, const CXXMethodDecl *MD) { 4023 auto DefaultCC = C.getDefaultCallingConvention(/*IsVariadic=*/false, 4024 /*IsCSSMethod=*/true); 4025 auto CC = MD->getType()->getAs<FunctionProtoType>()->getCallConv(); 4026 return CC == DefaultCC; 4027 }; 4028 4029 if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND)) { 4030 Manglings.emplace_back(getMangledStructor(M, DL, CD, Ctor_Base)); 4031 4032 if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily()) 4033 if (!CD->getParent()->isAbstract()) 4034 Manglings.emplace_back(getMangledStructor(M, DL, CD, Ctor_Complete)); 4035 4036 if (Ctx.getTargetInfo().getCXXABI().isMicrosoft()) 4037 if (CD->hasAttr<DLLExportAttr>() && CD->isDefaultConstructor()) 4038 if (!(hasDefaultCXXMethodCC(Ctx, CD) && CD->getNumParams() == 0)) 4039 Manglings.emplace_back(getMangledStructor(M, DL, CD, 4040 Ctor_DefaultClosure)); 4041 } else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND)) { 4042 Manglings.emplace_back(getMangledStructor(M, DL, DD, Dtor_Base)); 4043 if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily()) { 4044 Manglings.emplace_back(getMangledStructor(M, DL, DD, Dtor_Complete)); 4045 if (DD->isVirtual()) 4046 Manglings.emplace_back(getMangledStructor(M, DL, DD, Dtor_Deleting)); 4047 } 4048 } 4049 4050 return cxstring::createSet(Manglings); 4051} 4052 4053CXString clang_getCursorDisplayName(CXCursor C) { 4054 if (!clang_isDeclaration(C.kind)) 4055 return clang_getCursorSpelling(C); 4056 4057 const Decl *D = getCursorDecl(C); 4058 if (!D) 4059 return cxstring::createEmpty(); 4060 4061 PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy(); 4062 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 4063 D = FunTmpl->getTemplatedDecl(); 4064 4065 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 4066 SmallString<64> Str; 4067 llvm::raw_svector_ostream OS(Str); 4068 OS << *Function; 4069 if (Function->getPrimaryTemplate()) 4070 OS << "<>"; 4071 OS << "("; 4072 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) { 4073 if (I) 4074 OS << ", "; 4075 OS << Function->getParamDecl(I)->getType().getAsString(Policy); 4076 } 4077 4078 if (Function->isVariadic()) { 4079 if (Function->getNumParams()) 4080 OS << ", "; 4081 OS << "..."; 4082 } 4083 OS << ")"; 4084 return cxstring::createDup(OS.str()); 4085 } 4086 4087 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) { 4088 SmallString<64> Str; 4089 llvm::raw_svector_ostream OS(Str); 4090 OS << *ClassTemplate; 4091 OS << "<"; 4092 TemplateParameterList *Params = ClassTemplate->getTemplateParameters(); 4093 for (unsigned I = 0, N = Params->size(); I != N; ++I) { 4094 if (I) 4095 OS << ", "; 4096 4097 NamedDecl *Param = Params->getParam(I); 4098 if (Param->getIdentifier()) { 4099 OS << Param->getIdentifier()->getName(); 4100 continue; 4101 } 4102 4103 // There is no parameter name, which makes this tricky. Try to come up 4104 // with something useful that isn't too long. 4105 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 4106 OS << (TTP->wasDeclaredWithTypename()? "typename" : "class"); 4107 else if (NonTypeTemplateParmDecl *NTTP 4108 = dyn_cast<NonTypeTemplateParmDecl>(Param)) 4109 OS << NTTP->getType().getAsString(Policy); 4110 else 4111 OS << "template<...> class"; 4112 } 4113 4114 OS << ">"; 4115 return cxstring::createDup(OS.str()); 4116 } 4117 4118 if (const ClassTemplateSpecializationDecl *ClassSpec 4119 = dyn_cast<ClassTemplateSpecializationDecl>(D)) { 4120 // If the type was explicitly written, use that. 4121 if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten()) 4122 return cxstring::createDup(TSInfo->getType().getAsString(Policy)); 4123 4124 SmallString<128> Str; 4125 llvm::raw_svector_ostream OS(Str); 4126 OS << *ClassSpec; 4127 TemplateSpecializationType::PrintTemplateArgumentList(OS, 4128 ClassSpec->getTemplateArgs().data(), 4129 ClassSpec->getTemplateArgs().size(), 4130 Policy); 4131 return cxstring::createDup(OS.str()); 4132 } 4133 4134 return clang_getCursorSpelling(C); 4135} 4136 4137CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) { 4138 switch (Kind) { 4139 case CXCursor_FunctionDecl: 4140 return cxstring::createRef("FunctionDecl"); 4141 case CXCursor_TypedefDecl: 4142 return cxstring::createRef("TypedefDecl"); 4143 case CXCursor_EnumDecl: 4144 return cxstring::createRef("EnumDecl"); 4145 case CXCursor_EnumConstantDecl: 4146 return cxstring::createRef("EnumConstantDecl"); 4147 case CXCursor_StructDecl: 4148 return cxstring::createRef("StructDecl"); 4149 case CXCursor_UnionDecl: 4150 return cxstring::createRef("UnionDecl"); 4151 case CXCursor_ClassDecl: 4152 return cxstring::createRef("ClassDecl"); 4153 case CXCursor_FieldDecl: 4154 return cxstring::createRef("FieldDecl"); 4155 case CXCursor_VarDecl: 4156 return cxstring::createRef("VarDecl"); 4157 case CXCursor_ParmDecl: 4158 return cxstring::createRef("ParmDecl"); 4159 case CXCursor_ObjCInterfaceDecl: 4160 return cxstring::createRef("ObjCInterfaceDecl"); 4161 case CXCursor_ObjCCategoryDecl: 4162 return cxstring::createRef("ObjCCategoryDecl"); 4163 case CXCursor_ObjCProtocolDecl: 4164 return cxstring::createRef("ObjCProtocolDecl"); 4165 case CXCursor_ObjCPropertyDecl: 4166 return cxstring::createRef("ObjCPropertyDecl"); 4167 case CXCursor_ObjCIvarDecl: 4168 return cxstring::createRef("ObjCIvarDecl"); 4169 case CXCursor_ObjCInstanceMethodDecl: 4170 return cxstring::createRef("ObjCInstanceMethodDecl"); 4171 case CXCursor_ObjCClassMethodDecl: 4172 return cxstring::createRef("ObjCClassMethodDecl"); 4173 case CXCursor_ObjCImplementationDecl: 4174 return cxstring::createRef("ObjCImplementationDecl"); 4175 case CXCursor_ObjCCategoryImplDecl: 4176 return cxstring::createRef("ObjCCategoryImplDecl"); 4177 case CXCursor_CXXMethod: 4178 return cxstring::createRef("CXXMethod"); 4179 case CXCursor_UnexposedDecl: 4180 return cxstring::createRef("UnexposedDecl"); 4181 case CXCursor_ObjCSuperClassRef: 4182 return cxstring::createRef("ObjCSuperClassRef"); 4183 case CXCursor_ObjCProtocolRef: 4184 return cxstring::createRef("ObjCProtocolRef"); 4185 case CXCursor_ObjCClassRef: 4186 return cxstring::createRef("ObjCClassRef"); 4187 case CXCursor_TypeRef: 4188 return cxstring::createRef("TypeRef"); 4189 case CXCursor_TemplateRef: 4190 return cxstring::createRef("TemplateRef"); 4191 case CXCursor_NamespaceRef: 4192 return cxstring::createRef("NamespaceRef"); 4193 case CXCursor_MemberRef: 4194 return cxstring::createRef("MemberRef"); 4195 case CXCursor_LabelRef: 4196 return cxstring::createRef("LabelRef"); 4197 case CXCursor_OverloadedDeclRef: 4198 return cxstring::createRef("OverloadedDeclRef"); 4199 case CXCursor_VariableRef: 4200 return cxstring::createRef("VariableRef"); 4201 case CXCursor_IntegerLiteral: 4202 return cxstring::createRef("IntegerLiteral"); 4203 case CXCursor_FloatingLiteral: 4204 return cxstring::createRef("FloatingLiteral"); 4205 case CXCursor_ImaginaryLiteral: 4206 return cxstring::createRef("ImaginaryLiteral"); 4207 case CXCursor_StringLiteral: 4208 return cxstring::createRef("StringLiteral"); 4209 case CXCursor_CharacterLiteral: 4210 return cxstring::createRef("CharacterLiteral"); 4211 case CXCursor_ParenExpr: 4212 return cxstring::createRef("ParenExpr"); 4213 case CXCursor_UnaryOperator: 4214 return cxstring::createRef("UnaryOperator"); 4215 case CXCursor_ArraySubscriptExpr: 4216 return cxstring::createRef("ArraySubscriptExpr"); 4217 case CXCursor_OMPArraySectionExpr: 4218 return cxstring::createRef("OMPArraySectionExpr"); 4219 case CXCursor_BinaryOperator: 4220 return cxstring::createRef("BinaryOperator"); 4221 case CXCursor_CompoundAssignOperator: 4222 return cxstring::createRef("CompoundAssignOperator"); 4223 case CXCursor_ConditionalOperator: 4224 return cxstring::createRef("ConditionalOperator"); 4225 case CXCursor_CStyleCastExpr: 4226 return cxstring::createRef("CStyleCastExpr"); 4227 case CXCursor_CompoundLiteralExpr: 4228 return cxstring::createRef("CompoundLiteralExpr"); 4229 case CXCursor_InitListExpr: 4230 return cxstring::createRef("InitListExpr"); 4231 case CXCursor_AddrLabelExpr: 4232 return cxstring::createRef("AddrLabelExpr"); 4233 case CXCursor_StmtExpr: 4234 return cxstring::createRef("StmtExpr"); 4235 case CXCursor_GenericSelectionExpr: 4236 return cxstring::createRef("GenericSelectionExpr"); 4237 case CXCursor_GNUNullExpr: 4238 return cxstring::createRef("GNUNullExpr"); 4239 case CXCursor_CXXStaticCastExpr: 4240 return cxstring::createRef("CXXStaticCastExpr"); 4241 case CXCursor_CXXDynamicCastExpr: 4242 return cxstring::createRef("CXXDynamicCastExpr"); 4243 case CXCursor_CXXReinterpretCastExpr: 4244 return cxstring::createRef("CXXReinterpretCastExpr"); 4245 case CXCursor_CXXConstCastExpr: 4246 return cxstring::createRef("CXXConstCastExpr"); 4247 case CXCursor_CXXFunctionalCastExpr: 4248 return cxstring::createRef("CXXFunctionalCastExpr"); 4249 case CXCursor_CXXTypeidExpr: 4250 return cxstring::createRef("CXXTypeidExpr"); 4251 case CXCursor_CXXBoolLiteralExpr: 4252 return cxstring::createRef("CXXBoolLiteralExpr"); 4253 case CXCursor_CXXNullPtrLiteralExpr: 4254 return cxstring::createRef("CXXNullPtrLiteralExpr"); 4255 case CXCursor_CXXThisExpr: 4256 return cxstring::createRef("CXXThisExpr"); 4257 case CXCursor_CXXThrowExpr: 4258 return cxstring::createRef("CXXThrowExpr"); 4259 case CXCursor_CXXNewExpr: 4260 return cxstring::createRef("CXXNewExpr"); 4261 case CXCursor_CXXDeleteExpr: 4262 return cxstring::createRef("CXXDeleteExpr"); 4263 case CXCursor_UnaryExpr: 4264 return cxstring::createRef("UnaryExpr"); 4265 case CXCursor_ObjCStringLiteral: 4266 return cxstring::createRef("ObjCStringLiteral"); 4267 case CXCursor_ObjCBoolLiteralExpr: 4268 return cxstring::createRef("ObjCBoolLiteralExpr"); 4269 case CXCursor_ObjCSelfExpr: 4270 return cxstring::createRef("ObjCSelfExpr"); 4271 case CXCursor_ObjCEncodeExpr: 4272 return cxstring::createRef("ObjCEncodeExpr"); 4273 case CXCursor_ObjCSelectorExpr: 4274 return cxstring::createRef("ObjCSelectorExpr"); 4275 case CXCursor_ObjCProtocolExpr: 4276 return cxstring::createRef("ObjCProtocolExpr"); 4277 case CXCursor_ObjCBridgedCastExpr: 4278 return cxstring::createRef("ObjCBridgedCastExpr"); 4279 case CXCursor_BlockExpr: 4280 return cxstring::createRef("BlockExpr"); 4281 case CXCursor_PackExpansionExpr: 4282 return cxstring::createRef("PackExpansionExpr"); 4283 case CXCursor_SizeOfPackExpr: 4284 return cxstring::createRef("SizeOfPackExpr"); 4285 case CXCursor_LambdaExpr: 4286 return cxstring::createRef("LambdaExpr"); 4287 case CXCursor_UnexposedExpr: 4288 return cxstring::createRef("UnexposedExpr"); 4289 case CXCursor_DeclRefExpr: 4290 return cxstring::createRef("DeclRefExpr"); 4291 case CXCursor_MemberRefExpr: 4292 return cxstring::createRef("MemberRefExpr"); 4293 case CXCursor_CallExpr: 4294 return cxstring::createRef("CallExpr"); 4295 case CXCursor_ObjCMessageExpr: 4296 return cxstring::createRef("ObjCMessageExpr"); 4297 case CXCursor_UnexposedStmt: 4298 return cxstring::createRef("UnexposedStmt"); 4299 case CXCursor_DeclStmt: 4300 return cxstring::createRef("DeclStmt"); 4301 case CXCursor_LabelStmt: 4302 return cxstring::createRef("LabelStmt"); 4303 case CXCursor_CompoundStmt: 4304 return cxstring::createRef("CompoundStmt"); 4305 case CXCursor_CaseStmt: 4306 return cxstring::createRef("CaseStmt"); 4307 case CXCursor_DefaultStmt: 4308 return cxstring::createRef("DefaultStmt"); 4309 case CXCursor_IfStmt: 4310 return cxstring::createRef("IfStmt"); 4311 case CXCursor_SwitchStmt: 4312 return cxstring::createRef("SwitchStmt"); 4313 case CXCursor_WhileStmt: 4314 return cxstring::createRef("WhileStmt"); 4315 case CXCursor_DoStmt: 4316 return cxstring::createRef("DoStmt"); 4317 case CXCursor_ForStmt: 4318 return cxstring::createRef("ForStmt"); 4319 case CXCursor_GotoStmt: 4320 return cxstring::createRef("GotoStmt"); 4321 case CXCursor_IndirectGotoStmt: 4322 return cxstring::createRef("IndirectGotoStmt"); 4323 case CXCursor_ContinueStmt: 4324 return cxstring::createRef("ContinueStmt"); 4325 case CXCursor_BreakStmt: 4326 return cxstring::createRef("BreakStmt"); 4327 case CXCursor_ReturnStmt: 4328 return cxstring::createRef("ReturnStmt"); 4329 case CXCursor_GCCAsmStmt: 4330 return cxstring::createRef("GCCAsmStmt"); 4331 case CXCursor_MSAsmStmt: 4332 return cxstring::createRef("MSAsmStmt"); 4333 case CXCursor_ObjCAtTryStmt: 4334 return cxstring::createRef("ObjCAtTryStmt"); 4335 case CXCursor_ObjCAtCatchStmt: 4336 return cxstring::createRef("ObjCAtCatchStmt"); 4337 case CXCursor_ObjCAtFinallyStmt: 4338 return cxstring::createRef("ObjCAtFinallyStmt"); 4339 case CXCursor_ObjCAtThrowStmt: 4340 return cxstring::createRef("ObjCAtThrowStmt"); 4341 case CXCursor_ObjCAtSynchronizedStmt: 4342 return cxstring::createRef("ObjCAtSynchronizedStmt"); 4343 case CXCursor_ObjCAutoreleasePoolStmt: 4344 return cxstring::createRef("ObjCAutoreleasePoolStmt"); 4345 case CXCursor_ObjCForCollectionStmt: 4346 return cxstring::createRef("ObjCForCollectionStmt"); 4347 case CXCursor_CXXCatchStmt: 4348 return cxstring::createRef("CXXCatchStmt"); 4349 case CXCursor_CXXTryStmt: 4350 return cxstring::createRef("CXXTryStmt"); 4351 case CXCursor_CXXForRangeStmt: 4352 return cxstring::createRef("CXXForRangeStmt"); 4353 case CXCursor_SEHTryStmt: 4354 return cxstring::createRef("SEHTryStmt"); 4355 case CXCursor_SEHExceptStmt: 4356 return cxstring::createRef("SEHExceptStmt"); 4357 case CXCursor_SEHFinallyStmt: 4358 return cxstring::createRef("SEHFinallyStmt"); 4359 case CXCursor_SEHLeaveStmt: 4360 return cxstring::createRef("SEHLeaveStmt"); 4361 case CXCursor_NullStmt: 4362 return cxstring::createRef("NullStmt"); 4363 case CXCursor_InvalidFile: 4364 return cxstring::createRef("InvalidFile"); 4365 case CXCursor_InvalidCode: 4366 return cxstring::createRef("InvalidCode"); 4367 case CXCursor_NoDeclFound: 4368 return cxstring::createRef("NoDeclFound"); 4369 case CXCursor_NotImplemented: 4370 return cxstring::createRef("NotImplemented"); 4371 case CXCursor_TranslationUnit: 4372 return cxstring::createRef("TranslationUnit"); 4373 case CXCursor_UnexposedAttr: 4374 return cxstring::createRef("UnexposedAttr"); 4375 case CXCursor_IBActionAttr: 4376 return cxstring::createRef("attribute(ibaction)"); 4377 case CXCursor_IBOutletAttr: 4378 return cxstring::createRef("attribute(iboutlet)"); 4379 case CXCursor_IBOutletCollectionAttr: 4380 return cxstring::createRef("attribute(iboutletcollection)"); 4381 case CXCursor_CXXFinalAttr: 4382 return cxstring::createRef("attribute(final)"); 4383 case CXCursor_CXXOverrideAttr: 4384 return cxstring::createRef("attribute(override)"); 4385 case CXCursor_AnnotateAttr: 4386 return cxstring::createRef("attribute(annotate)"); 4387 case CXCursor_AsmLabelAttr: 4388 return cxstring::createRef("asm label"); 4389 case CXCursor_PackedAttr: 4390 return cxstring::createRef("attribute(packed)"); 4391 case CXCursor_PureAttr: 4392 return cxstring::createRef("attribute(pure)"); 4393 case CXCursor_ConstAttr: 4394 return cxstring::createRef("attribute(const)"); 4395 case CXCursor_NoDuplicateAttr: 4396 return cxstring::createRef("attribute(noduplicate)"); 4397 case CXCursor_CUDAConstantAttr: 4398 return cxstring::createRef("attribute(constant)"); 4399 case CXCursor_CUDADeviceAttr: 4400 return cxstring::createRef("attribute(device)"); 4401 case CXCursor_CUDAGlobalAttr: 4402 return cxstring::createRef("attribute(global)"); 4403 case CXCursor_CUDAHostAttr: 4404 return cxstring::createRef("attribute(host)"); 4405 case CXCursor_CUDASharedAttr: 4406 return cxstring::createRef("attribute(shared)"); 4407 case CXCursor_VisibilityAttr: 4408 return cxstring::createRef("attribute(visibility)"); 4409 case CXCursor_DLLExport: 4410 return cxstring::createRef("attribute(dllexport)"); 4411 case CXCursor_DLLImport: 4412 return cxstring::createRef("attribute(dllimport)"); 4413 case CXCursor_PreprocessingDirective: 4414 return cxstring::createRef("preprocessing directive"); 4415 case CXCursor_MacroDefinition: 4416 return cxstring::createRef("macro definition"); 4417 case CXCursor_MacroExpansion: 4418 return cxstring::createRef("macro expansion"); 4419 case CXCursor_InclusionDirective: 4420 return cxstring::createRef("inclusion directive"); 4421 case CXCursor_Namespace: 4422 return cxstring::createRef("Namespace"); 4423 case CXCursor_LinkageSpec: 4424 return cxstring::createRef("LinkageSpec"); 4425 case CXCursor_CXXBaseSpecifier: 4426 return cxstring::createRef("C++ base class specifier"); 4427 case CXCursor_Constructor: 4428 return cxstring::createRef("CXXConstructor"); 4429 case CXCursor_Destructor: 4430 return cxstring::createRef("CXXDestructor"); 4431 case CXCursor_ConversionFunction: 4432 return cxstring::createRef("CXXConversion"); 4433 case CXCursor_TemplateTypeParameter: 4434 return cxstring::createRef("TemplateTypeParameter"); 4435 case CXCursor_NonTypeTemplateParameter: 4436 return cxstring::createRef("NonTypeTemplateParameter"); 4437 case CXCursor_TemplateTemplateParameter: 4438 return cxstring::createRef("TemplateTemplateParameter"); 4439 case CXCursor_FunctionTemplate: 4440 return cxstring::createRef("FunctionTemplate"); 4441 case CXCursor_ClassTemplate: 4442 return cxstring::createRef("ClassTemplate"); 4443 case CXCursor_ClassTemplatePartialSpecialization: 4444 return cxstring::createRef("ClassTemplatePartialSpecialization"); 4445 case CXCursor_NamespaceAlias: 4446 return cxstring::createRef("NamespaceAlias"); 4447 case CXCursor_UsingDirective: 4448 return cxstring::createRef("UsingDirective"); 4449 case CXCursor_UsingDeclaration: 4450 return cxstring::createRef("UsingDeclaration"); 4451 case CXCursor_TypeAliasDecl: 4452 return cxstring::createRef("TypeAliasDecl"); 4453 case CXCursor_ObjCSynthesizeDecl: 4454 return cxstring::createRef("ObjCSynthesizeDecl"); 4455 case CXCursor_ObjCDynamicDecl: 4456 return cxstring::createRef("ObjCDynamicDecl"); 4457 case CXCursor_CXXAccessSpecifier: 4458 return cxstring::createRef("CXXAccessSpecifier"); 4459 case CXCursor_ModuleImportDecl: 4460 return cxstring::createRef("ModuleImport"); 4461 case CXCursor_OMPParallelDirective: 4462 return cxstring::createRef("OMPParallelDirective"); 4463 case CXCursor_OMPSimdDirective: 4464 return cxstring::createRef("OMPSimdDirective"); 4465 case CXCursor_OMPForDirective: 4466 return cxstring::createRef("OMPForDirective"); 4467 case CXCursor_OMPForSimdDirective: 4468 return cxstring::createRef("OMPForSimdDirective"); 4469 case CXCursor_OMPSectionsDirective: 4470 return cxstring::createRef("OMPSectionsDirective"); 4471 case CXCursor_OMPSectionDirective: 4472 return cxstring::createRef("OMPSectionDirective"); 4473 case CXCursor_OMPSingleDirective: 4474 return cxstring::createRef("OMPSingleDirective"); 4475 case CXCursor_OMPMasterDirective: 4476 return cxstring::createRef("OMPMasterDirective"); 4477 case CXCursor_OMPCriticalDirective: 4478 return cxstring::createRef("OMPCriticalDirective"); 4479 case CXCursor_OMPParallelForDirective: 4480 return cxstring::createRef("OMPParallelForDirective"); 4481 case CXCursor_OMPParallelForSimdDirective: 4482 return cxstring::createRef("OMPParallelForSimdDirective"); 4483 case CXCursor_OMPParallelSectionsDirective: 4484 return cxstring::createRef("OMPParallelSectionsDirective"); 4485 case CXCursor_OMPTaskDirective: 4486 return cxstring::createRef("OMPTaskDirective"); 4487 case CXCursor_OMPTaskyieldDirective: 4488 return cxstring::createRef("OMPTaskyieldDirective"); 4489 case CXCursor_OMPBarrierDirective: 4490 return cxstring::createRef("OMPBarrierDirective"); 4491 case CXCursor_OMPTaskwaitDirective: 4492 return cxstring::createRef("OMPTaskwaitDirective"); 4493 case CXCursor_OMPTaskgroupDirective: 4494 return cxstring::createRef("OMPTaskgroupDirective"); 4495 case CXCursor_OMPFlushDirective: 4496 return cxstring::createRef("OMPFlushDirective"); 4497 case CXCursor_OMPOrderedDirective: 4498 return cxstring::createRef("OMPOrderedDirective"); 4499 case CXCursor_OMPAtomicDirective: 4500 return cxstring::createRef("OMPAtomicDirective"); 4501 case CXCursor_OMPTargetDirective: 4502 return cxstring::createRef("OMPTargetDirective"); 4503 case CXCursor_OMPTargetDataDirective: 4504 return cxstring::createRef("OMPTargetDataDirective"); 4505 case CXCursor_OMPTeamsDirective: 4506 return cxstring::createRef("OMPTeamsDirective"); 4507 case CXCursor_OMPCancellationPointDirective: 4508 return cxstring::createRef("OMPCancellationPointDirective"); 4509 case CXCursor_OMPCancelDirective: 4510 return cxstring::createRef("OMPCancelDirective"); 4511 case CXCursor_OMPTaskLoopDirective: 4512 return cxstring::createRef("OMPTaskLoopDirective"); 4513 case CXCursor_OMPTaskLoopSimdDirective: 4514 return cxstring::createRef("OMPTaskLoopSimdDirective"); 4515 case CXCursor_OMPDistributeDirective: 4516 return cxstring::createRef("OMPDistributeDirective"); 4517 case CXCursor_OverloadCandidate: 4518 return cxstring::createRef("OverloadCandidate"); 4519 case CXCursor_TypeAliasTemplateDecl: 4520 return cxstring::createRef("TypeAliasTemplateDecl"); 4521 } 4522 4523 llvm_unreachable("Unhandled CXCursorKind"); 4524} 4525 4526struct GetCursorData { 4527 SourceLocation TokenBeginLoc; 4528 bool PointsAtMacroArgExpansion; 4529 bool VisitedObjCPropertyImplDecl; 4530 SourceLocation VisitedDeclaratorDeclStartLoc; 4531 CXCursor &BestCursor; 4532 4533 GetCursorData(SourceManager &SM, 4534 SourceLocation tokenBegin, CXCursor &outputCursor) 4535 : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) { 4536 PointsAtMacroArgExpansion = SM.isMacroArgExpansion(tokenBegin); 4537 VisitedObjCPropertyImplDecl = false; 4538 } 4539}; 4540 4541static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor, 4542 CXCursor parent, 4543 CXClientData client_data) { 4544 GetCursorData *Data = static_cast<GetCursorData *>(client_data); 4545 CXCursor *BestCursor = &Data->BestCursor; 4546 4547 // If we point inside a macro argument we should provide info of what the 4548 // token is so use the actual cursor, don't replace it with a macro expansion 4549 // cursor. 4550 if (cursor.kind == CXCursor_MacroExpansion && Data->PointsAtMacroArgExpansion) 4551 return CXChildVisit_Recurse; 4552 4553 if (clang_isDeclaration(cursor.kind)) { 4554 // Avoid having the implicit methods override the property decls. 4555 if (const ObjCMethodDecl *MD 4556 = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) { 4557 if (MD->isImplicit()) 4558 return CXChildVisit_Break; 4559 4560 } else if (const ObjCInterfaceDecl *ID 4561 = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(cursor))) { 4562 // Check that when we have multiple @class references in the same line, 4563 // that later ones do not override the previous ones. 4564 // If we have: 4565 // @class Foo, Bar; 4566 // source ranges for both start at '@', so 'Bar' will end up overriding 4567 // 'Foo' even though the cursor location was at 'Foo'. 4568 if (BestCursor->kind == CXCursor_ObjCInterfaceDecl || 4569 BestCursor->kind == CXCursor_ObjCClassRef) 4570 if (const ObjCInterfaceDecl *PrevID 4571 = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(*BestCursor))){ 4572 if (PrevID != ID && 4573 !PrevID->isThisDeclarationADefinition() && 4574 !ID->isThisDeclarationADefinition()) 4575 return CXChildVisit_Break; 4576 } 4577 4578 } else if (const DeclaratorDecl *DD 4579 = dyn_cast_or_null<DeclaratorDecl>(getCursorDecl(cursor))) { 4580 SourceLocation StartLoc = DD->getSourceRange().getBegin(); 4581 // Check that when we have multiple declarators in the same line, 4582 // that later ones do not override the previous ones. 4583 // If we have: 4584 // int Foo, Bar; 4585 // source ranges for both start at 'int', so 'Bar' will end up overriding 4586 // 'Foo' even though the cursor location was at 'Foo'. 4587 if (Data->VisitedDeclaratorDeclStartLoc == StartLoc) 4588 return CXChildVisit_Break; 4589 Data->VisitedDeclaratorDeclStartLoc = StartLoc; 4590 4591 } else if (const ObjCPropertyImplDecl *PropImp 4592 = dyn_cast_or_null<ObjCPropertyImplDecl>(getCursorDecl(cursor))) { 4593 (void)PropImp; 4594 // Check that when we have multiple @synthesize in the same line, 4595 // that later ones do not override the previous ones. 4596 // If we have: 4597 // @synthesize Foo, Bar; 4598 // source ranges for both start at '@', so 'Bar' will end up overriding 4599 // 'Foo' even though the cursor location was at 'Foo'. 4600 if (Data->VisitedObjCPropertyImplDecl) 4601 return CXChildVisit_Break; 4602 Data->VisitedObjCPropertyImplDecl = true; 4603 } 4604 } 4605 4606 if (clang_isExpression(cursor.kind) && 4607 clang_isDeclaration(BestCursor->kind)) { 4608 if (const Decl *D = getCursorDecl(*BestCursor)) { 4609 // Avoid having the cursor of an expression replace the declaration cursor 4610 // when the expression source range overlaps the declaration range. 4611 // This can happen for C++ constructor expressions whose range generally 4612 // include the variable declaration, e.g.: 4613 // MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl cursor. 4614 if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() && 4615 D->getLocation() == Data->TokenBeginLoc) 4616 return CXChildVisit_Break; 4617 } 4618 } 4619 4620 // If our current best cursor is the construction of a temporary object, 4621 // don't replace that cursor with a type reference, because we want 4622 // clang_getCursor() to point at the constructor. 4623 if (clang_isExpression(BestCursor->kind) && 4624 isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) && 4625 cursor.kind == CXCursor_TypeRef) { 4626 // Keep the cursor pointing at CXXTemporaryObjectExpr but also mark it 4627 // as having the actual point on the type reference. 4628 *BestCursor = getTypeRefedCallExprCursor(*BestCursor); 4629 return CXChildVisit_Recurse; 4630 } 4631 4632 // If we already have an Objective-C superclass reference, don't 4633 // update it further. 4634 if (BestCursor->kind == CXCursor_ObjCSuperClassRef) 4635 return CXChildVisit_Break; 4636 4637 *BestCursor = cursor; 4638 return CXChildVisit_Recurse; 4639} 4640 4641CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) { 4642 if (isNotUsableTU(TU)) { 4643 LOG_BAD_TU(TU); 4644 return clang_getNullCursor(); 4645 } 4646 4647 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4648 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 4649 4650 SourceLocation SLoc = cxloc::translateSourceLocation(Loc); 4651 CXCursor Result = cxcursor::getCursor(TU, SLoc); 4652 4653 LOG_FUNC_SECTION { 4654 CXFile SearchFile; 4655 unsigned SearchLine, SearchColumn; 4656 CXFile ResultFile; 4657 unsigned ResultLine, ResultColumn; 4658 CXString SearchFileName, ResultFileName, KindSpelling, USR; 4659 const char *IsDef = clang_isCursorDefinition(Result)? " (Definition)" : ""; 4660 CXSourceLocation ResultLoc = clang_getCursorLocation(Result); 4661 4662 clang_getFileLocation(Loc, &SearchFile, &SearchLine, &SearchColumn, 4663 nullptr); 4664 clang_getFileLocation(ResultLoc, &ResultFile, &ResultLine, 4665 &ResultColumn, nullptr); 4666 SearchFileName = clang_getFileName(SearchFile); 4667 ResultFileName = clang_getFileName(ResultFile); 4668 KindSpelling = clang_getCursorKindSpelling(Result.kind); 4669 USR = clang_getCursorUSR(Result); 4670 *Log << llvm::format("(%s:%d:%d) = %s", 4671 clang_getCString(SearchFileName), SearchLine, SearchColumn, 4672 clang_getCString(KindSpelling)) 4673 << llvm::format("(%s:%d:%d):%s%s", 4674 clang_getCString(ResultFileName), ResultLine, ResultColumn, 4675 clang_getCString(USR), IsDef); 4676 clang_disposeString(SearchFileName); 4677 clang_disposeString(ResultFileName); 4678 clang_disposeString(KindSpelling); 4679 clang_disposeString(USR); 4680 4681 CXCursor Definition = clang_getCursorDefinition(Result); 4682 if (!clang_equalCursors(Definition, clang_getNullCursor())) { 4683 CXSourceLocation DefinitionLoc = clang_getCursorLocation(Definition); 4684 CXString DefinitionKindSpelling 4685 = clang_getCursorKindSpelling(Definition.kind); 4686 CXFile DefinitionFile; 4687 unsigned DefinitionLine, DefinitionColumn; 4688 clang_getFileLocation(DefinitionLoc, &DefinitionFile, 4689 &DefinitionLine, &DefinitionColumn, nullptr); 4690 CXString DefinitionFileName = clang_getFileName(DefinitionFile); 4691 *Log << llvm::format(" -> %s(%s:%d:%d)", 4692 clang_getCString(DefinitionKindSpelling), 4693 clang_getCString(DefinitionFileName), 4694 DefinitionLine, DefinitionColumn); 4695 clang_disposeString(DefinitionFileName); 4696 clang_disposeString(DefinitionKindSpelling); 4697 } 4698 } 4699 4700 return Result; 4701} 4702 4703CXCursor clang_getNullCursor(void) { 4704 return MakeCXCursorInvalid(CXCursor_InvalidFile); 4705} 4706 4707unsigned clang_equalCursors(CXCursor X, CXCursor Y) { 4708 // Clear out the "FirstInDeclGroup" part in a declaration cursor, since we 4709 // can't set consistently. For example, when visiting a DeclStmt we will set 4710 // it but we don't set it on the result of clang_getCursorDefinition for 4711 // a reference of the same declaration. 4712 // FIXME: Setting "FirstInDeclGroup" in CXCursors is a hack that only works 4713 // when visiting a DeclStmt currently, the AST should be enhanced to be able 4714 // to provide that kind of info. 4715 if (clang_isDeclaration(X.kind)) 4716 X.data[1] = nullptr; 4717 if (clang_isDeclaration(Y.kind)) 4718 Y.data[1] = nullptr; 4719 4720 return X == Y; 4721} 4722 4723unsigned clang_hashCursor(CXCursor C) { 4724 unsigned Index = 0; 4725 if (clang_isExpression(C.kind) || clang_isStatement(C.kind)) 4726 Index = 1; 4727 4728 return llvm::DenseMapInfo<std::pair<unsigned, const void*> >::getHashValue( 4729 std::make_pair(C.kind, C.data[Index])); 4730} 4731 4732unsigned clang_isInvalid(enum CXCursorKind K) { 4733 return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid; 4734} 4735 4736unsigned clang_isDeclaration(enum CXCursorKind K) { 4737 return (K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl) || 4738 (K >= CXCursor_FirstExtraDecl && K <= CXCursor_LastExtraDecl); 4739} 4740 4741unsigned clang_isReference(enum CXCursorKind K) { 4742 return K >= CXCursor_FirstRef && K <= CXCursor_LastRef; 4743} 4744 4745unsigned clang_isExpression(enum CXCursorKind K) { 4746 return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr; 4747} 4748 4749unsigned clang_isStatement(enum CXCursorKind K) { 4750 return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt; 4751} 4752 4753unsigned clang_isAttribute(enum CXCursorKind K) { 4754 return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr; 4755} 4756 4757unsigned clang_isTranslationUnit(enum CXCursorKind K) { 4758 return K == CXCursor_TranslationUnit; 4759} 4760 4761unsigned clang_isPreprocessing(enum CXCursorKind K) { 4762 return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing; 4763} 4764 4765unsigned clang_isUnexposed(enum CXCursorKind K) { 4766 switch (K) { 4767 case CXCursor_UnexposedDecl: 4768 case CXCursor_UnexposedExpr: 4769 case CXCursor_UnexposedStmt: 4770 case CXCursor_UnexposedAttr: 4771 return true; 4772 default: 4773 return false; 4774 } 4775} 4776 4777CXCursorKind clang_getCursorKind(CXCursor C) { 4778 return C.kind; 4779} 4780 4781CXSourceLocation clang_getCursorLocation(CXCursor C) { 4782 if (clang_isReference(C.kind)) { 4783 switch (C.kind) { 4784 case CXCursor_ObjCSuperClassRef: { 4785 std::pair<const ObjCInterfaceDecl *, SourceLocation> P 4786 = getCursorObjCSuperClassRef(C); 4787 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4788 } 4789 4790 case CXCursor_ObjCProtocolRef: { 4791 std::pair<const ObjCProtocolDecl *, SourceLocation> P 4792 = getCursorObjCProtocolRef(C); 4793 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4794 } 4795 4796 case CXCursor_ObjCClassRef: { 4797 std::pair<const ObjCInterfaceDecl *, SourceLocation> P 4798 = getCursorObjCClassRef(C); 4799 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4800 } 4801 4802 case CXCursor_TypeRef: { 4803 std::pair<const TypeDecl *, SourceLocation> P = getCursorTypeRef(C); 4804 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4805 } 4806 4807 case CXCursor_TemplateRef: { 4808 std::pair<const TemplateDecl *, SourceLocation> P = 4809 getCursorTemplateRef(C); 4810 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4811 } 4812 4813 case CXCursor_NamespaceRef: { 4814 std::pair<const NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C); 4815 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4816 } 4817 4818 case CXCursor_MemberRef: { 4819 std::pair<const FieldDecl *, SourceLocation> P = getCursorMemberRef(C); 4820 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4821 } 4822 4823 case CXCursor_VariableRef: { 4824 std::pair<const VarDecl *, SourceLocation> P = getCursorVariableRef(C); 4825 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 4826 } 4827 4828 case CXCursor_CXXBaseSpecifier: { 4829 const CXXBaseSpecifier *BaseSpec = getCursorCXXBaseSpecifier(C); 4830 if (!BaseSpec) 4831 return clang_getNullLocation(); 4832 4833 if (TypeSourceInfo *TSInfo = BaseSpec->getTypeSourceInfo()) 4834 return cxloc::translateSourceLocation(getCursorContext(C), 4835 TSInfo->getTypeLoc().getBeginLoc()); 4836 4837 return cxloc::translateSourceLocation(getCursorContext(C), 4838 BaseSpec->getLocStart()); 4839 } 4840 4841 case CXCursor_LabelRef: { 4842 std::pair<const LabelStmt *, SourceLocation> P = getCursorLabelRef(C); 4843 return cxloc::translateSourceLocation(getCursorContext(C), P.second); 4844 } 4845 4846 case CXCursor_OverloadedDeclRef: 4847 return cxloc::translateSourceLocation(getCursorContext(C), 4848 getCursorOverloadedDeclRef(C).second); 4849 4850 default: 4851 // FIXME: Need a way to enumerate all non-reference cases. 4852 llvm_unreachable("Missed a reference kind"); 4853 } 4854 } 4855 4856 if (clang_isExpression(C.kind)) 4857 return cxloc::translateSourceLocation(getCursorContext(C), 4858 getLocationFromExpr(getCursorExpr(C))); 4859 4860 if (clang_isStatement(C.kind)) 4861 return cxloc::translateSourceLocation(getCursorContext(C), 4862 getCursorStmt(C)->getLocStart()); 4863 4864 if (C.kind == CXCursor_PreprocessingDirective) { 4865 SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin(); 4866 return cxloc::translateSourceLocation(getCursorContext(C), L); 4867 } 4868 4869 if (C.kind == CXCursor_MacroExpansion) { 4870 SourceLocation L 4871 = cxcursor::getCursorMacroExpansion(C).getSourceRange().getBegin(); 4872 return cxloc::translateSourceLocation(getCursorContext(C), L); 4873 } 4874 4875 if (C.kind == CXCursor_MacroDefinition) { 4876 SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation(); 4877 return cxloc::translateSourceLocation(getCursorContext(C), L); 4878 } 4879 4880 if (C.kind == CXCursor_InclusionDirective) { 4881 SourceLocation L 4882 = cxcursor::getCursorInclusionDirective(C)->getSourceRange().getBegin(); 4883 return cxloc::translateSourceLocation(getCursorContext(C), L); 4884 } 4885 4886 if (clang_isAttribute(C.kind)) { 4887 SourceLocation L 4888 = cxcursor::getCursorAttr(C)->getLocation(); 4889 return cxloc::translateSourceLocation(getCursorContext(C), L); 4890 } 4891 4892 if (!clang_isDeclaration(C.kind)) 4893 return clang_getNullLocation(); 4894 4895 const Decl *D = getCursorDecl(C); 4896 if (!D) 4897 return clang_getNullLocation(); 4898 4899 SourceLocation Loc = D->getLocation(); 4900 // FIXME: Multiple variables declared in a single declaration 4901 // currently lack the information needed to correctly determine their 4902 // ranges when accounting for the type-specifier. We use context 4903 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 4904 // and if so, whether it is the first decl. 4905 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 4906 if (!cxcursor::isFirstInDeclGroup(C)) 4907 Loc = VD->getLocation(); 4908 } 4909 4910 // For ObjC methods, give the start location of the method name. 4911 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 4912 Loc = MD->getSelectorStartLoc(); 4913 4914 return cxloc::translateSourceLocation(getCursorContext(C), Loc); 4915} 4916 4917} // end extern "C" 4918 4919CXCursor cxcursor::getCursor(CXTranslationUnit TU, SourceLocation SLoc) { 4920 assert(TU); 4921 4922 // Guard against an invalid SourceLocation, or we may assert in one 4923 // of the following calls. 4924 if (SLoc.isInvalid()) 4925 return clang_getNullCursor(); 4926 4927 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4928 4929 // Translate the given source location to make it point at the beginning of 4930 // the token under the cursor. 4931 SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(), 4932 CXXUnit->getASTContext().getLangOpts()); 4933 4934 CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound); 4935 if (SLoc.isValid()) { 4936 GetCursorData ResultData(CXXUnit->getSourceManager(), SLoc, Result); 4937 CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData, 4938 /*VisitPreprocessorLast=*/true, 4939 /*VisitIncludedEntities=*/false, 4940 SourceLocation(SLoc)); 4941 CursorVis.visitFileRegion(); 4942 } 4943 4944 return Result; 4945} 4946 4947static SourceRange getRawCursorExtent(CXCursor C) { 4948 if (clang_isReference(C.kind)) { 4949 switch (C.kind) { 4950 case CXCursor_ObjCSuperClassRef: 4951 return getCursorObjCSuperClassRef(C).second; 4952 4953 case CXCursor_ObjCProtocolRef: 4954 return getCursorObjCProtocolRef(C).second; 4955 4956 case CXCursor_ObjCClassRef: 4957 return getCursorObjCClassRef(C).second; 4958 4959 case CXCursor_TypeRef: 4960 return getCursorTypeRef(C).second; 4961 4962 case CXCursor_TemplateRef: 4963 return getCursorTemplateRef(C).second; 4964 4965 case CXCursor_NamespaceRef: 4966 return getCursorNamespaceRef(C).second; 4967 4968 case CXCursor_MemberRef: 4969 return getCursorMemberRef(C).second; 4970 4971 case CXCursor_CXXBaseSpecifier: 4972 return getCursorCXXBaseSpecifier(C)->getSourceRange(); 4973 4974 case CXCursor_LabelRef: 4975 return getCursorLabelRef(C).second; 4976 4977 case CXCursor_OverloadedDeclRef: 4978 return getCursorOverloadedDeclRef(C).second; 4979 4980 case CXCursor_VariableRef: 4981 return getCursorVariableRef(C).second; 4982 4983 default: 4984 // FIXME: Need a way to enumerate all non-reference cases. 4985 llvm_unreachable("Missed a reference kind"); 4986 } 4987 } 4988 4989 if (clang_isExpression(C.kind)) 4990 return getCursorExpr(C)->getSourceRange(); 4991 4992 if (clang_isStatement(C.kind)) 4993 return getCursorStmt(C)->getSourceRange(); 4994 4995 if (clang_isAttribute(C.kind)) 4996 return getCursorAttr(C)->getRange(); 4997 4998 if (C.kind == CXCursor_PreprocessingDirective) 4999 return cxcursor::getCursorPreprocessingDirective(C); 5000 5001 if (C.kind == CXCursor_MacroExpansion) { 5002 ASTUnit *TU = getCursorASTUnit(C); 5003 SourceRange Range = cxcursor::getCursorMacroExpansion(C).getSourceRange(); 5004 return TU->mapRangeFromPreamble(Range); 5005 } 5006 5007 if (C.kind == CXCursor_MacroDefinition) { 5008 ASTUnit *TU = getCursorASTUnit(C); 5009 SourceRange Range = cxcursor::getCursorMacroDefinition(C)->getSourceRange(); 5010 return TU->mapRangeFromPreamble(Range); 5011 } 5012 5013 if (C.kind == CXCursor_InclusionDirective) { 5014 ASTUnit *TU = getCursorASTUnit(C); 5015 SourceRange Range = cxcursor::getCursorInclusionDirective(C)->getSourceRange(); 5016 return TU->mapRangeFromPreamble(Range); 5017 } 5018 5019 if (C.kind == CXCursor_TranslationUnit) { 5020 ASTUnit *TU = getCursorASTUnit(C); 5021 FileID MainID = TU->getSourceManager().getMainFileID(); 5022 SourceLocation Start = TU->getSourceManager().getLocForStartOfFile(MainID); 5023 SourceLocation End = TU->getSourceManager().getLocForEndOfFile(MainID); 5024 return SourceRange(Start, End); 5025 } 5026 5027 if (clang_isDeclaration(C.kind)) { 5028 const Decl *D = cxcursor::getCursorDecl(C); 5029 if (!D) 5030 return SourceRange(); 5031 5032 SourceRange R = D->getSourceRange(); 5033 // FIXME: Multiple variables declared in a single declaration 5034 // currently lack the information needed to correctly determine their 5035 // ranges when accounting for the type-specifier. We use context 5036 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 5037 // and if so, whether it is the first decl. 5038 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 5039 if (!cxcursor::isFirstInDeclGroup(C)) 5040 R.setBegin(VD->getLocation()); 5041 } 5042 return R; 5043 } 5044 return SourceRange(); 5045} 5046 5047/// \brief Retrieves the "raw" cursor extent, which is then extended to include 5048/// the decl-specifier-seq for declarations. 5049static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) { 5050 if (clang_isDeclaration(C.kind)) { 5051 const Decl *D = cxcursor::getCursorDecl(C); 5052 if (!D) 5053 return SourceRange(); 5054 5055 SourceRange R = D->getSourceRange(); 5056 5057 // Adjust the start of the location for declarations preceded by 5058 // declaration specifiers. 5059 SourceLocation StartLoc; 5060 if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) { 5061 if (TypeSourceInfo *TI = DD->getTypeSourceInfo()) 5062 StartLoc = TI->getTypeLoc().getLocStart(); 5063 } else if (const TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) { 5064 if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo()) 5065 StartLoc = TI->getTypeLoc().getLocStart(); 5066 } 5067 5068 if (StartLoc.isValid() && R.getBegin().isValid() && 5069 SrcMgr.isBeforeInTranslationUnit(StartLoc, R.getBegin())) 5070 R.setBegin(StartLoc); 5071 5072 // FIXME: Multiple variables declared in a single declaration 5073 // currently lack the information needed to correctly determine their 5074 // ranges when accounting for the type-specifier. We use context 5075 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 5076 // and if so, whether it is the first decl. 5077 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 5078 if (!cxcursor::isFirstInDeclGroup(C)) 5079 R.setBegin(VD->getLocation()); 5080 } 5081 5082 return R; 5083 } 5084 5085 return getRawCursorExtent(C); 5086} 5087 5088extern "C" { 5089 5090CXSourceRange clang_getCursorExtent(CXCursor C) { 5091 SourceRange R = getRawCursorExtent(C); 5092 if (R.isInvalid()) 5093 return clang_getNullRange(); 5094 5095 return cxloc::translateSourceRange(getCursorContext(C), R); 5096} 5097 5098CXCursor clang_getCursorReferenced(CXCursor C) { 5099 if (clang_isInvalid(C.kind)) 5100 return clang_getNullCursor(); 5101 5102 CXTranslationUnit tu = getCursorTU(C); 5103 if (clang_isDeclaration(C.kind)) { 5104 const Decl *D = getCursorDecl(C); 5105 if (!D) 5106 return clang_getNullCursor(); 5107 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) 5108 return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu); 5109 if (const ObjCPropertyImplDecl *PropImpl = 5110 dyn_cast<ObjCPropertyImplDecl>(D)) 5111 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 5112 return MakeCXCursor(Property, tu); 5113 5114 return C; 5115 } 5116 5117 if (clang_isExpression(C.kind)) { 5118 const Expr *E = getCursorExpr(C); 5119 const Decl *D = getDeclFromExpr(E); 5120 if (D) { 5121 CXCursor declCursor = MakeCXCursor(D, tu); 5122 declCursor = getSelectorIdentifierCursor(getSelectorIdentifierIndex(C), 5123 declCursor); 5124 return declCursor; 5125 } 5126 5127 if (const OverloadExpr *Ovl = dyn_cast_or_null<OverloadExpr>(E)) 5128 return MakeCursorOverloadedDeclRef(Ovl, tu); 5129 5130 return clang_getNullCursor(); 5131 } 5132 5133 if (clang_isStatement(C.kind)) { 5134 const Stmt *S = getCursorStmt(C); 5135 if (const GotoStmt *Goto = dyn_cast_or_null<GotoStmt>(S)) 5136 if (LabelDecl *label = Goto->getLabel()) 5137 if (LabelStmt *labelS = label->getStmt()) 5138 return MakeCXCursor(labelS, getCursorDecl(C), tu); 5139 5140 return clang_getNullCursor(); 5141 } 5142 5143 if (C.kind == CXCursor_MacroExpansion) { 5144 if (const MacroDefinitionRecord *Def = 5145 getCursorMacroExpansion(C).getDefinition()) 5146 return MakeMacroDefinitionCursor(Def, tu); 5147 } 5148 5149 if (!clang_isReference(C.kind)) 5150 return clang_getNullCursor(); 5151 5152 switch (C.kind) { 5153 case CXCursor_ObjCSuperClassRef: 5154 return MakeCXCursor(getCursorObjCSuperClassRef(C).first, tu); 5155 5156 case CXCursor_ObjCProtocolRef: { 5157 const ObjCProtocolDecl *Prot = getCursorObjCProtocolRef(C).first; 5158 if (const ObjCProtocolDecl *Def = Prot->getDefinition()) 5159 return MakeCXCursor(Def, tu); 5160 5161 return MakeCXCursor(Prot, tu); 5162 } 5163 5164 case CXCursor_ObjCClassRef: { 5165 const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first; 5166 if (const ObjCInterfaceDecl *Def = Class->getDefinition()) 5167 return MakeCXCursor(Def, tu); 5168 5169 return MakeCXCursor(Class, tu); 5170 } 5171 5172 case CXCursor_TypeRef: 5173 return MakeCXCursor(getCursorTypeRef(C).first, tu ); 5174 5175 case CXCursor_TemplateRef: 5176 return MakeCXCursor(getCursorTemplateRef(C).first, tu ); 5177 5178 case CXCursor_NamespaceRef: 5179 return MakeCXCursor(getCursorNamespaceRef(C).first, tu ); 5180 5181 case CXCursor_MemberRef: 5182 return MakeCXCursor(getCursorMemberRef(C).first, tu ); 5183 5184 case CXCursor_CXXBaseSpecifier: { 5185 const CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C); 5186 return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(), 5187 tu )); 5188 } 5189 5190 case CXCursor_LabelRef: 5191 // FIXME: We end up faking the "parent" declaration here because we 5192 // don't want to make CXCursor larger. 5193 return MakeCXCursor(getCursorLabelRef(C).first, 5194 cxtu::getASTUnit(tu)->getASTContext() 5195 .getTranslationUnitDecl(), 5196 tu); 5197 5198 case CXCursor_OverloadedDeclRef: 5199 return C; 5200 5201 case CXCursor_VariableRef: 5202 return MakeCXCursor(getCursorVariableRef(C).first, tu); 5203 5204 default: 5205 // We would prefer to enumerate all non-reference cursor kinds here. 5206 llvm_unreachable("Unhandled reference cursor kind"); 5207 } 5208} 5209 5210CXCursor clang_getCursorDefinition(CXCursor C) { 5211 if (clang_isInvalid(C.kind)) 5212 return clang_getNullCursor(); 5213 5214 CXTranslationUnit TU = getCursorTU(C); 5215 5216 bool WasReference = false; 5217 if (clang_isReference(C.kind) || clang_isExpression(C.kind)) { 5218 C = clang_getCursorReferenced(C); 5219 WasReference = true; 5220 } 5221 5222 if (C.kind == CXCursor_MacroExpansion) 5223 return clang_getCursorReferenced(C); 5224 5225 if (!clang_isDeclaration(C.kind)) 5226 return clang_getNullCursor(); 5227 5228 const Decl *D = getCursorDecl(C); 5229 if (!D) 5230 return clang_getNullCursor(); 5231 5232 switch (D->getKind()) { 5233 // Declaration kinds that don't really separate the notions of 5234 // declaration and definition. 5235 case Decl::Namespace: 5236 case Decl::Typedef: 5237 case Decl::TypeAlias: 5238 case Decl::TypeAliasTemplate: 5239 case Decl::TemplateTypeParm: 5240 case Decl::EnumConstant: 5241 case Decl::Field: 5242 case Decl::MSProperty: 5243 case Decl::IndirectField: 5244 case Decl::ObjCIvar: 5245 case Decl::ObjCAtDefsField: 5246 case Decl::ImplicitParam: 5247 case Decl::ParmVar: 5248 case Decl::NonTypeTemplateParm: 5249 case Decl::TemplateTemplateParm: 5250 case Decl::ObjCCategoryImpl: 5251 case Decl::ObjCImplementation: 5252 case Decl::AccessSpec: 5253 case Decl::LinkageSpec: 5254 case Decl::ObjCPropertyImpl: 5255 case Decl::FileScopeAsm: 5256 case Decl::StaticAssert: 5257 case Decl::Block: 5258 case Decl::Captured: 5259 case Decl::Label: // FIXME: Is this right?? 5260 case Decl::ClassScopeFunctionSpecialization: 5261 case Decl::Import: 5262 case Decl::OMPThreadPrivate: 5263 case Decl::ObjCTypeParam: 5264 case Decl::BuiltinTemplate: 5265 return C; 5266 5267 // Declaration kinds that don't make any sense here, but are 5268 // nonetheless harmless. 5269 case Decl::Empty: 5270 case Decl::TranslationUnit: 5271 case Decl::ExternCContext: 5272 break; 5273 5274 // Declaration kinds for which the definition is not resolvable. 5275 case Decl::UnresolvedUsingTypename: 5276 case Decl::UnresolvedUsingValue: 5277 break; 5278 5279 case Decl::UsingDirective: 5280 return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(), 5281 TU); 5282 5283 case Decl::NamespaceAlias: 5284 return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), TU); 5285 5286 case Decl::Enum: 5287 case Decl::Record: 5288 case Decl::CXXRecord: 5289 case Decl::ClassTemplateSpecialization: 5290 case Decl::ClassTemplatePartialSpecialization: 5291 if (TagDecl *Def = cast<TagDecl>(D)->getDefinition()) 5292 return MakeCXCursor(Def, TU); 5293 return clang_getNullCursor(); 5294 5295 case Decl::Function: 5296 case Decl::CXXMethod: 5297 case Decl::CXXConstructor: 5298 case Decl::CXXDestructor: 5299 case Decl::CXXConversion: { 5300 const FunctionDecl *Def = nullptr; 5301 if (cast<FunctionDecl>(D)->getBody(Def)) 5302 return MakeCXCursor(Def, TU); 5303 return clang_getNullCursor(); 5304 } 5305 5306 case Decl::Var: 5307 case Decl::VarTemplateSpecialization: 5308 case Decl::VarTemplatePartialSpecialization: { 5309 // Ask the variable if it has a definition. 5310 if (const VarDecl *Def = cast<VarDecl>(D)->getDefinition()) 5311 return MakeCXCursor(Def, TU); 5312 return clang_getNullCursor(); 5313 } 5314 5315 case Decl::FunctionTemplate: { 5316 const FunctionDecl *Def = nullptr; 5317 if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def)) 5318 return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU); 5319 return clang_getNullCursor(); 5320 } 5321 5322 case Decl::ClassTemplate: { 5323 if (RecordDecl *Def = cast<ClassTemplateDecl>(D)->getTemplatedDecl() 5324 ->getDefinition()) 5325 return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(), 5326 TU); 5327 return clang_getNullCursor(); 5328 } 5329 5330 case Decl::VarTemplate: { 5331 if (VarDecl *Def = 5332 cast<VarTemplateDecl>(D)->getTemplatedDecl()->getDefinition()) 5333 return MakeCXCursor(cast<VarDecl>(Def)->getDescribedVarTemplate(), TU); 5334 return clang_getNullCursor(); 5335 } 5336 5337 case Decl::Using: 5338 return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D), 5339 D->getLocation(), TU); 5340 5341 case Decl::UsingShadow: 5342 return clang_getCursorDefinition( 5343 MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(), 5344 TU)); 5345 5346 case Decl::ObjCMethod: { 5347 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D); 5348 if (Method->isThisDeclarationADefinition()) 5349 return C; 5350 5351 // Dig out the method definition in the associated 5352 // @implementation, if we have it. 5353 // FIXME: The ASTs should make finding the definition easier. 5354 if (const ObjCInterfaceDecl *Class 5355 = dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) 5356 if (ObjCImplementationDecl *ClassImpl = Class->getImplementation()) 5357 if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(), 5358 Method->isInstanceMethod())) 5359 if (Def->isThisDeclarationADefinition()) 5360 return MakeCXCursor(Def, TU); 5361 5362 return clang_getNullCursor(); 5363 } 5364 5365 case Decl::ObjCCategory: 5366 if (ObjCCategoryImplDecl *Impl 5367 = cast<ObjCCategoryDecl>(D)->getImplementation()) 5368 return MakeCXCursor(Impl, TU); 5369 return clang_getNullCursor(); 5370 5371 case Decl::ObjCProtocol: 5372 if (const ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(D)->getDefinition()) 5373 return MakeCXCursor(Def, TU); 5374 return clang_getNullCursor(); 5375 5376 case Decl::ObjCInterface: { 5377 // There are two notions of a "definition" for an Objective-C 5378 // class: the interface and its implementation. When we resolved a 5379 // reference to an Objective-C class, produce the @interface as 5380 // the definition; when we were provided with the interface, 5381 // produce the @implementation as the definition. 5382 const ObjCInterfaceDecl *IFace = cast<ObjCInterfaceDecl>(D); 5383 if (WasReference) { 5384 if (const ObjCInterfaceDecl *Def = IFace->getDefinition()) 5385 return MakeCXCursor(Def, TU); 5386 } else if (ObjCImplementationDecl *Impl = IFace->getImplementation()) 5387 return MakeCXCursor(Impl, TU); 5388 return clang_getNullCursor(); 5389 } 5390 5391 case Decl::ObjCProperty: 5392 // FIXME: We don't really know where to find the 5393 // ObjCPropertyImplDecls that implement this property. 5394 return clang_getNullCursor(); 5395 5396 case Decl::ObjCCompatibleAlias: 5397 if (const ObjCInterfaceDecl *Class 5398 = cast<ObjCCompatibleAliasDecl>(D)->getClassInterface()) 5399 if (const ObjCInterfaceDecl *Def = Class->getDefinition()) 5400 return MakeCXCursor(Def, TU); 5401 5402 return clang_getNullCursor(); 5403 5404 case Decl::Friend: 5405 if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl()) 5406 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 5407 return clang_getNullCursor(); 5408 5409 case Decl::FriendTemplate: 5410 if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl()) 5411 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 5412 return clang_getNullCursor(); 5413 } 5414 5415 return clang_getNullCursor(); 5416} 5417 5418unsigned clang_isCursorDefinition(CXCursor C) { 5419 if (!clang_isDeclaration(C.kind)) 5420 return 0; 5421 5422 return clang_getCursorDefinition(C) == C; 5423} 5424 5425CXCursor clang_getCanonicalCursor(CXCursor C) { 5426 if (!clang_isDeclaration(C.kind)) 5427 return C; 5428 5429 if (const Decl *D = getCursorDecl(C)) { 5430 if (const ObjCCategoryImplDecl *CatImplD = dyn_cast<ObjCCategoryImplDecl>(D)) 5431 if (ObjCCategoryDecl *CatD = CatImplD->getCategoryDecl()) 5432 return MakeCXCursor(CatD, getCursorTU(C)); 5433 5434 if (const ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 5435 if (const ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) 5436 return MakeCXCursor(IFD, getCursorTU(C)); 5437 5438 return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C)); 5439 } 5440 5441 return C; 5442} 5443 5444int clang_Cursor_getObjCSelectorIndex(CXCursor cursor) { 5445 return cxcursor::getSelectorIdentifierIndexAndLoc(cursor).first; 5446} 5447 5448unsigned clang_getNumOverloadedDecls(CXCursor C) { 5449 if (C.kind != CXCursor_OverloadedDeclRef) 5450 return 0; 5451 5452 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 5453 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>()) 5454 return E->getNumDecls(); 5455 5456 if (OverloadedTemplateStorage *S 5457 = Storage.dyn_cast<OverloadedTemplateStorage*>()) 5458 return S->size(); 5459 5460 const Decl *D = Storage.get<const Decl *>(); 5461 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) 5462 return Using->shadow_size(); 5463 5464 return 0; 5465} 5466 5467CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) { 5468 if (cursor.kind != CXCursor_OverloadedDeclRef) 5469 return clang_getNullCursor(); 5470 5471 if (index >= clang_getNumOverloadedDecls(cursor)) 5472 return clang_getNullCursor(); 5473 5474 CXTranslationUnit TU = getCursorTU(cursor); 5475 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first; 5476 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>()) 5477 return MakeCXCursor(E->decls_begin()[index], TU); 5478 5479 if (OverloadedTemplateStorage *S 5480 = Storage.dyn_cast<OverloadedTemplateStorage*>()) 5481 return MakeCXCursor(S->begin()[index], TU); 5482 5483 const Decl *D = Storage.get<const Decl *>(); 5484 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) { 5485 // FIXME: This is, unfortunately, linear time. 5486 UsingDecl::shadow_iterator Pos = Using->shadow_begin(); 5487 std::advance(Pos, index); 5488 return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU); 5489 } 5490 5491 return clang_getNullCursor(); 5492} 5493 5494void clang_getDefinitionSpellingAndExtent(CXCursor C, 5495 const char **startBuf, 5496 const char **endBuf, 5497 unsigned *startLine, 5498 unsigned *startColumn, 5499 unsigned *endLine, 5500 unsigned *endColumn) { 5501 assert(getCursorDecl(C) && "CXCursor has null decl"); 5502 const FunctionDecl *FD = dyn_cast<FunctionDecl>(getCursorDecl(C)); 5503 CompoundStmt *Body = dyn_cast<CompoundStmt>(FD->getBody()); 5504 5505 SourceManager &SM = FD->getASTContext().getSourceManager(); 5506 *startBuf = SM.getCharacterData(Body->getLBracLoc()); 5507 *endBuf = SM.getCharacterData(Body->getRBracLoc()); 5508 *startLine = SM.getSpellingLineNumber(Body->getLBracLoc()); 5509 *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc()); 5510 *endLine = SM.getSpellingLineNumber(Body->getRBracLoc()); 5511 *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc()); 5512} 5513 5514 5515CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags, 5516 unsigned PieceIndex) { 5517 RefNamePieces Pieces; 5518 5519 switch (C.kind) { 5520 case CXCursor_MemberRefExpr: 5521 if (const MemberExpr *E = dyn_cast<MemberExpr>(getCursorExpr(C))) 5522 Pieces = buildPieces(NameFlags, true, E->getMemberNameInfo(), 5523 E->getQualifierLoc().getSourceRange()); 5524 break; 5525 5526 case CXCursor_DeclRefExpr: 5527 if (const DeclRefExpr *E = dyn_cast<DeclRefExpr>(getCursorExpr(C))) 5528 Pieces = buildPieces(NameFlags, false, E->getNameInfo(), 5529 E->getQualifierLoc().getSourceRange(), 5530 E->getOptionalExplicitTemplateArgs()); 5531 break; 5532 5533 case CXCursor_CallExpr: 5534 if (const CXXOperatorCallExpr *OCE = 5535 dyn_cast<CXXOperatorCallExpr>(getCursorExpr(C))) { 5536 const Expr *Callee = OCE->getCallee(); 5537 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee)) 5538 Callee = ICE->getSubExpr(); 5539 5540 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) 5541 Pieces = buildPieces(NameFlags, false, DRE->getNameInfo(), 5542 DRE->getQualifierLoc().getSourceRange()); 5543 } 5544 break; 5545 5546 default: 5547 break; 5548 } 5549 5550 if (Pieces.empty()) { 5551 if (PieceIndex == 0) 5552 return clang_getCursorExtent(C); 5553 } else if (PieceIndex < Pieces.size()) { 5554 SourceRange R = Pieces[PieceIndex]; 5555 if (R.isValid()) 5556 return cxloc::translateSourceRange(getCursorContext(C), R); 5557 } 5558 5559 return clang_getNullRange(); 5560} 5561 5562void clang_enableStackTraces(void) { 5563 llvm::sys::PrintStackTraceOnErrorSignal(); 5564} 5565 5566void clang_executeOnThread(void (*fn)(void*), void *user_data, 5567 unsigned stack_size) { 5568 llvm::llvm_execute_on_thread(fn, user_data, stack_size); 5569} 5570 5571} // end: extern "C" 5572 5573//===----------------------------------------------------------------------===// 5574// Token-based Operations. 5575//===----------------------------------------------------------------------===// 5576 5577/* CXToken layout: 5578 * int_data[0]: a CXTokenKind 5579 * int_data[1]: starting token location 5580 * int_data[2]: token length 5581 * int_data[3]: reserved 5582 * ptr_data: for identifiers and keywords, an IdentifierInfo*. 5583 * otherwise unused. 5584 */ 5585extern "C" { 5586 5587CXTokenKind clang_getTokenKind(CXToken CXTok) { 5588 return static_cast<CXTokenKind>(CXTok.int_data[0]); 5589} 5590 5591CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) { 5592 switch (clang_getTokenKind(CXTok)) { 5593 case CXToken_Identifier: 5594 case CXToken_Keyword: 5595 // We know we have an IdentifierInfo*, so use that. 5596 return cxstring::createRef(static_cast<IdentifierInfo *>(CXTok.ptr_data) 5597 ->getNameStart()); 5598 5599 case CXToken_Literal: { 5600 // We have stashed the starting pointer in the ptr_data field. Use it. 5601 const char *Text = static_cast<const char *>(CXTok.ptr_data); 5602 return cxstring::createDup(StringRef(Text, CXTok.int_data[2])); 5603 } 5604 5605 case CXToken_Punctuation: 5606 case CXToken_Comment: 5607 break; 5608 } 5609 5610 if (isNotUsableTU(TU)) { 5611 LOG_BAD_TU(TU); 5612 return cxstring::createEmpty(); 5613 } 5614 5615 // We have to find the starting buffer pointer the hard way, by 5616 // deconstructing the source location. 5617 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 5618 if (!CXXUnit) 5619 return cxstring::createEmpty(); 5620 5621 SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]); 5622 std::pair<FileID, unsigned> LocInfo 5623 = CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc); 5624 bool Invalid = false; 5625 StringRef Buffer 5626 = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid); 5627 if (Invalid) 5628 return cxstring::createEmpty(); 5629 5630 return cxstring::createDup(Buffer.substr(LocInfo.second, CXTok.int_data[2])); 5631} 5632 5633CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) { 5634 if (isNotUsableTU(TU)) { 5635 LOG_BAD_TU(TU); 5636 return clang_getNullLocation(); 5637 } 5638 5639 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 5640 if (!CXXUnit) 5641 return clang_getNullLocation(); 5642 5643 return cxloc::translateSourceLocation(CXXUnit->getASTContext(), 5644 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 5645} 5646 5647CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) { 5648 if (isNotUsableTU(TU)) { 5649 LOG_BAD_TU(TU); 5650 return clang_getNullRange(); 5651 } 5652 5653 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 5654 if (!CXXUnit) 5655 return clang_getNullRange(); 5656 5657 return cxloc::translateSourceRange(CXXUnit->getASTContext(), 5658 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 5659} 5660 5661static void getTokens(ASTUnit *CXXUnit, SourceRange Range, 5662 SmallVectorImpl<CXToken> &CXTokens) { 5663 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 5664 std::pair<FileID, unsigned> BeginLocInfo 5665 = SourceMgr.getDecomposedSpellingLoc(Range.getBegin()); 5666 std::pair<FileID, unsigned> EndLocInfo 5667 = SourceMgr.getDecomposedSpellingLoc(Range.getEnd()); 5668 5669 // Cannot tokenize across files. 5670 if (BeginLocInfo.first != EndLocInfo.first) 5671 return; 5672 5673 // Create a lexer 5674 bool Invalid = false; 5675 StringRef Buffer 5676 = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid); 5677 if (Invalid) 5678 return; 5679 5680 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 5681 CXXUnit->getASTContext().getLangOpts(), 5682 Buffer.begin(), Buffer.data() + BeginLocInfo.second, Buffer.end()); 5683 Lex.SetCommentRetentionState(true); 5684 5685 // Lex tokens until we hit the end of the range. 5686 const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second; 5687 Token Tok; 5688 bool previousWasAt = false; 5689 do { 5690 // Lex the next token 5691 Lex.LexFromRawLexer(Tok); 5692 if (Tok.is(tok::eof)) 5693 break; 5694 5695 // Initialize the CXToken. 5696 CXToken CXTok; 5697 5698 // - Common fields 5699 CXTok.int_data[1] = Tok.getLocation().getRawEncoding(); 5700 CXTok.int_data[2] = Tok.getLength(); 5701 CXTok.int_data[3] = 0; 5702 5703 // - Kind-specific fields 5704 if (Tok.isLiteral()) { 5705 CXTok.int_data[0] = CXToken_Literal; 5706 CXTok.ptr_data = const_cast<char *>(Tok.getLiteralData()); 5707 } else if (Tok.is(tok::raw_identifier)) { 5708 // Lookup the identifier to determine whether we have a keyword. 5709 IdentifierInfo *II 5710 = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok); 5711 5712 if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) { 5713 CXTok.int_data[0] = CXToken_Keyword; 5714 } 5715 else { 5716 CXTok.int_data[0] = Tok.is(tok::identifier) 5717 ? CXToken_Identifier 5718 : CXToken_Keyword; 5719 } 5720 CXTok.ptr_data = II; 5721 } else if (Tok.is(tok::comment)) { 5722 CXTok.int_data[0] = CXToken_Comment; 5723 CXTok.ptr_data = nullptr; 5724 } else { 5725 CXTok.int_data[0] = CXToken_Punctuation; 5726 CXTok.ptr_data = nullptr; 5727 } 5728 CXTokens.push_back(CXTok); 5729 previousWasAt = Tok.is(tok::at); 5730 } while (Lex.getBufferLocation() <= EffectiveBufferEnd); 5731} 5732 5733void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range, 5734 CXToken **Tokens, unsigned *NumTokens) { 5735 LOG_FUNC_SECTION { 5736 *Log << TU << ' ' << Range; 5737 } 5738 5739 if (Tokens) 5740 *Tokens = nullptr; 5741 if (NumTokens) 5742 *NumTokens = 0; 5743 5744 if (isNotUsableTU(TU)) { 5745 LOG_BAD_TU(TU); 5746 return; 5747 } 5748 5749 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 5750 if (!CXXUnit || !Tokens || !NumTokens) 5751 return; 5752 5753 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 5754 5755 SourceRange R = cxloc::translateCXSourceRange(Range); 5756 if (R.isInvalid()) 5757 return; 5758 5759 SmallVector<CXToken, 32> CXTokens; 5760 getTokens(CXXUnit, R, CXTokens); 5761 5762 if (CXTokens.empty()) 5763 return; 5764 5765 *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size()); 5766 memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size()); 5767 *NumTokens = CXTokens.size(); 5768} 5769 5770void clang_disposeTokens(CXTranslationUnit TU, 5771 CXToken *Tokens, unsigned NumTokens) { 5772 free(Tokens); 5773} 5774 5775} // end: extern "C" 5776 5777//===----------------------------------------------------------------------===// 5778// Token annotation APIs. 5779//===----------------------------------------------------------------------===// 5780 5781static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 5782 CXCursor parent, 5783 CXClientData client_data); 5784static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor, 5785 CXClientData client_data); 5786 5787namespace { 5788class AnnotateTokensWorker { 5789 CXToken *Tokens; 5790 CXCursor *Cursors; 5791 unsigned NumTokens; 5792 unsigned TokIdx; 5793 unsigned PreprocessingTokIdx; 5794 CursorVisitor AnnotateVis; 5795 SourceManager &SrcMgr; 5796 bool HasContextSensitiveKeywords; 5797 5798 struct PostChildrenInfo { 5799 CXCursor Cursor; 5800 SourceRange CursorRange; 5801 unsigned BeforeReachingCursorIdx; 5802 unsigned BeforeChildrenTokenIdx; 5803 }; 5804 SmallVector<PostChildrenInfo, 8> PostChildrenInfos; 5805 5806 CXToken &getTok(unsigned Idx) { 5807 assert(Idx < NumTokens); 5808 return Tokens[Idx]; 5809 } 5810 const CXToken &getTok(unsigned Idx) const { 5811 assert(Idx < NumTokens); 5812 return Tokens[Idx]; 5813 } 5814 bool MoreTokens() const { return TokIdx < NumTokens; } 5815 unsigned NextToken() const { return TokIdx; } 5816 void AdvanceToken() { ++TokIdx; } 5817 SourceLocation GetTokenLoc(unsigned tokI) { 5818 return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]); 5819 } 5820 bool isFunctionMacroToken(unsigned tokI) const { 5821 return getTok(tokI).int_data[3] != 0; 5822 } 5823 SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const { 5824 return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[3]); 5825 } 5826 5827 void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange); 5828 bool annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult, 5829 SourceRange); 5830 5831public: 5832 AnnotateTokensWorker(CXToken *tokens, CXCursor *cursors, unsigned numTokens, 5833 CXTranslationUnit TU, SourceRange RegionOfInterest) 5834 : Tokens(tokens), Cursors(cursors), 5835 NumTokens(numTokens), TokIdx(0), PreprocessingTokIdx(0), 5836 AnnotateVis(TU, 5837 AnnotateTokensVisitor, this, 5838 /*VisitPreprocessorLast=*/true, 5839 /*VisitIncludedEntities=*/false, 5840 RegionOfInterest, 5841 /*VisitDeclsOnly=*/false, 5842 AnnotateTokensPostChildrenVisitor), 5843 SrcMgr(cxtu::getASTUnit(TU)->getSourceManager()), 5844 HasContextSensitiveKeywords(false) { } 5845 5846 void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); } 5847 enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent); 5848 bool postVisitChildren(CXCursor cursor); 5849 void AnnotateTokens(); 5850 5851 /// \brief Determine whether the annotator saw any cursors that have 5852 /// context-sensitive keywords. 5853 bool hasContextSensitiveKeywords() const { 5854 return HasContextSensitiveKeywords; 5855 } 5856 5857 ~AnnotateTokensWorker() { 5858 assert(PostChildrenInfos.empty()); 5859 } 5860}; 5861} 5862 5863void AnnotateTokensWorker::AnnotateTokens() { 5864 // Walk the AST within the region of interest, annotating tokens 5865 // along the way. 5866 AnnotateVis.visitFileRegion(); 5867} 5868 5869static inline void updateCursorAnnotation(CXCursor &Cursor, 5870 const CXCursor &updateC) { 5871 if (clang_isInvalid(updateC.kind) || !clang_isInvalid(Cursor.kind)) 5872 return; 5873 Cursor = updateC; 5874} 5875 5876/// \brief It annotates and advances tokens with a cursor until the comparison 5877//// between the cursor location and the source range is the same as 5878/// \arg compResult. 5879/// 5880/// Pass RangeBefore to annotate tokens with a cursor until a range is reached. 5881/// Pass RangeOverlap to annotate tokens inside a range. 5882void AnnotateTokensWorker::annotateAndAdvanceTokens(CXCursor updateC, 5883 RangeComparisonResult compResult, 5884 SourceRange range) { 5885 while (MoreTokens()) { 5886 const unsigned I = NextToken(); 5887 if (isFunctionMacroToken(I)) 5888 if (!annotateAndAdvanceFunctionMacroTokens(updateC, compResult, range)) 5889 return; 5890 5891 SourceLocation TokLoc = GetTokenLoc(I); 5892 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) { 5893 updateCursorAnnotation(Cursors[I], updateC); 5894 AdvanceToken(); 5895 continue; 5896 } 5897 break; 5898 } 5899} 5900 5901/// \brief Special annotation handling for macro argument tokens. 5902/// \returns true if it advanced beyond all macro tokens, false otherwise. 5903bool AnnotateTokensWorker::annotateAndAdvanceFunctionMacroTokens( 5904 CXCursor updateC, 5905 RangeComparisonResult compResult, 5906 SourceRange range) { 5907 assert(MoreTokens()); 5908 assert(isFunctionMacroToken(NextToken()) && 5909 "Should be called only for macro arg tokens"); 5910 5911 // This works differently than annotateAndAdvanceTokens; because expanded 5912 // macro arguments can have arbitrary translation-unit source order, we do not 5913 // advance the token index one by one until a token fails the range test. 5914 // We only advance once past all of the macro arg tokens if all of them 5915 // pass the range test. If one of them fails we keep the token index pointing 5916 // at the start of the macro arg tokens so that the failing token will be 5917 // annotated by a subsequent annotation try. 5918 5919 bool atLeastOneCompFail = false; 5920 5921 unsigned I = NextToken(); 5922 for (; I < NumTokens && isFunctionMacroToken(I); ++I) { 5923 SourceLocation TokLoc = getFunctionMacroTokenLoc(I); 5924 if (TokLoc.isFileID()) 5925 continue; // not macro arg token, it's parens or comma. 5926 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) { 5927 if (clang_isInvalid(clang_getCursorKind(Cursors[I]))) 5928 Cursors[I] = updateC; 5929 } else 5930 atLeastOneCompFail = true; 5931 } 5932 5933 if (atLeastOneCompFail) 5934 return false; 5935 5936 TokIdx = I; // All of the tokens were handled, advance beyond all of them. 5937 return true; 5938} 5939 5940enum CXChildVisitResult 5941AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) { 5942 SourceRange cursorRange = getRawCursorExtent(cursor); 5943 if (cursorRange.isInvalid()) 5944 return CXChildVisit_Recurse; 5945 5946 if (!HasContextSensitiveKeywords) { 5947 // Objective-C properties can have context-sensitive keywords. 5948 if (cursor.kind == CXCursor_ObjCPropertyDecl) { 5949 if (const ObjCPropertyDecl *Property 5950 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(cursor))) 5951 HasContextSensitiveKeywords = Property->getPropertyAttributesAsWritten() != 0; 5952 } 5953 // Objective-C methods can have context-sensitive keywords. 5954 else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl || 5955 cursor.kind == CXCursor_ObjCClassMethodDecl) { 5956 if (const ObjCMethodDecl *Method 5957 = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) { 5958 if (Method->getObjCDeclQualifier()) 5959 HasContextSensitiveKeywords = true; 5960 else { 5961 for (const auto *P : Method->params()) { 5962 if (P->getObjCDeclQualifier()) { 5963 HasContextSensitiveKeywords = true; 5964 break; 5965 } 5966 } 5967 } 5968 } 5969 } 5970 // C++ methods can have context-sensitive keywords. 5971 else if (cursor.kind == CXCursor_CXXMethod) { 5972 if (const CXXMethodDecl *Method 5973 = dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(cursor))) { 5974 if (Method->hasAttr<FinalAttr>() || Method->hasAttr<OverrideAttr>()) 5975 HasContextSensitiveKeywords = true; 5976 } 5977 } 5978 // C++ classes can have context-sensitive keywords. 5979 else if (cursor.kind == CXCursor_StructDecl || 5980 cursor.kind == CXCursor_ClassDecl || 5981 cursor.kind == CXCursor_ClassTemplate || 5982 cursor.kind == CXCursor_ClassTemplatePartialSpecialization) { 5983 if (const Decl *D = getCursorDecl(cursor)) 5984 if (D->hasAttr<FinalAttr>()) 5985 HasContextSensitiveKeywords = true; 5986 } 5987 } 5988 5989 // Don't override a property annotation with its getter/setter method. 5990 if (cursor.kind == CXCursor_ObjCInstanceMethodDecl && 5991 parent.kind == CXCursor_ObjCPropertyDecl) 5992 return CXChildVisit_Continue; 5993 5994 if (clang_isPreprocessing(cursor.kind)) { 5995 // Items in the preprocessing record are kept separate from items in 5996 // declarations, so we keep a separate token index. 5997 unsigned SavedTokIdx = TokIdx; 5998 TokIdx = PreprocessingTokIdx; 5999 6000 // Skip tokens up until we catch up to the beginning of the preprocessing 6001 // entry. 6002 while (MoreTokens()) { 6003 const unsigned I = NextToken(); 6004 SourceLocation TokLoc = GetTokenLoc(I); 6005 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 6006 case RangeBefore: 6007 AdvanceToken(); 6008 continue; 6009 case RangeAfter: 6010 case RangeOverlap: 6011 break; 6012 } 6013 break; 6014 } 6015 6016 // Look at all of the tokens within this range. 6017 while (MoreTokens()) { 6018 const unsigned I = NextToken(); 6019 SourceLocation TokLoc = GetTokenLoc(I); 6020 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 6021 case RangeBefore: 6022 llvm_unreachable("Infeasible"); 6023 case RangeAfter: 6024 break; 6025 case RangeOverlap: 6026 // For macro expansions, just note where the beginning of the macro 6027 // expansion occurs. 6028 if (cursor.kind == CXCursor_MacroExpansion) { 6029 if (TokLoc == cursorRange.getBegin()) 6030 Cursors[I] = cursor; 6031 AdvanceToken(); 6032 break; 6033 } 6034 // We may have already annotated macro names inside macro definitions. 6035 if (Cursors[I].kind != CXCursor_MacroExpansion) 6036 Cursors[I] = cursor; 6037 AdvanceToken(); 6038 continue; 6039 } 6040 break; 6041 } 6042 6043 // Save the preprocessing token index; restore the non-preprocessing 6044 // token index. 6045 PreprocessingTokIdx = TokIdx; 6046 TokIdx = SavedTokIdx; 6047 return CXChildVisit_Recurse; 6048 } 6049 6050 if (cursorRange.isInvalid()) 6051 return CXChildVisit_Continue; 6052 6053 unsigned BeforeReachingCursorIdx = NextToken(); 6054 const enum CXCursorKind cursorK = clang_getCursorKind(cursor); 6055 const enum CXCursorKind K = clang_getCursorKind(parent); 6056 const CXCursor updateC = 6057 (clang_isInvalid(K) || K == CXCursor_TranslationUnit || 6058 // Attributes are annotated out-of-order, skip tokens until we reach it. 6059 clang_isAttribute(cursor.kind)) 6060 ? clang_getNullCursor() : parent; 6061 6062 annotateAndAdvanceTokens(updateC, RangeBefore, cursorRange); 6063 6064 // Avoid having the cursor of an expression "overwrite" the annotation of the 6065 // variable declaration that it belongs to. 6066 // This can happen for C++ constructor expressions whose range generally 6067 // include the variable declaration, e.g.: 6068 // MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor. 6069 if (clang_isExpression(cursorK) && MoreTokens()) { 6070 const Expr *E = getCursorExpr(cursor); 6071 if (const Decl *D = getCursorParentDecl(cursor)) { 6072 const unsigned I = NextToken(); 6073 if (E->getLocStart().isValid() && D->getLocation().isValid() && 6074 E->getLocStart() == D->getLocation() && 6075 E->getLocStart() == GetTokenLoc(I)) { 6076 updateCursorAnnotation(Cursors[I], updateC); 6077 AdvanceToken(); 6078 } 6079 } 6080 } 6081 6082 // Before recursing into the children keep some state that we are going 6083 // to use in the AnnotateTokensWorker::postVisitChildren callback to do some 6084 // extra work after the child nodes are visited. 6085 // Note that we don't call VisitChildren here to avoid traversing statements 6086 // code-recursively which can blow the stack. 6087 6088 PostChildrenInfo Info; 6089 Info.Cursor = cursor; 6090 Info.CursorRange = cursorRange; 6091 Info.BeforeReachingCursorIdx = BeforeReachingCursorIdx; 6092 Info.BeforeChildrenTokenIdx = NextToken(); 6093 PostChildrenInfos.push_back(Info); 6094 6095 return CXChildVisit_Recurse; 6096} 6097 6098bool AnnotateTokensWorker::postVisitChildren(CXCursor cursor) { 6099 if (PostChildrenInfos.empty()) 6100 return false; 6101 const PostChildrenInfo &Info = PostChildrenInfos.back(); 6102 if (!clang_equalCursors(Info.Cursor, cursor)) 6103 return false; 6104 6105 const unsigned BeforeChildren = Info.BeforeChildrenTokenIdx; 6106 const unsigned AfterChildren = NextToken(); 6107 SourceRange cursorRange = Info.CursorRange; 6108 6109 // Scan the tokens that are at the end of the cursor, but are not captured 6110 // but the child cursors. 6111 annotateAndAdvanceTokens(cursor, RangeOverlap, cursorRange); 6112 6113 // Scan the tokens that are at the beginning of the cursor, but are not 6114 // capture by the child cursors. 6115 for (unsigned I = BeforeChildren; I != AfterChildren; ++I) { 6116 if (!clang_isInvalid(clang_getCursorKind(Cursors[I]))) 6117 break; 6118 6119 Cursors[I] = cursor; 6120 } 6121 6122 // Attributes are annotated out-of-order, rewind TokIdx to when we first 6123 // encountered the attribute cursor. 6124 if (clang_isAttribute(cursor.kind)) 6125 TokIdx = Info.BeforeReachingCursorIdx; 6126 6127 PostChildrenInfos.pop_back(); 6128 return false; 6129} 6130 6131static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 6132 CXCursor parent, 6133 CXClientData client_data) { 6134 return static_cast<AnnotateTokensWorker*>(client_data)->Visit(cursor, parent); 6135} 6136 6137static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor, 6138 CXClientData client_data) { 6139 return static_cast<AnnotateTokensWorker*>(client_data)-> 6140 postVisitChildren(cursor); 6141} 6142 6143namespace { 6144 6145/// \brief Uses the macro expansions in the preprocessing record to find 6146/// and mark tokens that are macro arguments. This info is used by the 6147/// AnnotateTokensWorker. 6148class MarkMacroArgTokensVisitor { 6149 SourceManager &SM; 6150 CXToken *Tokens; 6151 unsigned NumTokens; 6152 unsigned CurIdx; 6153 6154public: 6155 MarkMacroArgTokensVisitor(SourceManager &SM, 6156 CXToken *tokens, unsigned numTokens) 6157 : SM(SM), Tokens(tokens), NumTokens(numTokens), CurIdx(0) { } 6158 6159 CXChildVisitResult visit(CXCursor cursor, CXCursor parent) { 6160 if (cursor.kind != CXCursor_MacroExpansion) 6161 return CXChildVisit_Continue; 6162 6163 SourceRange macroRange = getCursorMacroExpansion(cursor).getSourceRange(); 6164 if (macroRange.getBegin() == macroRange.getEnd()) 6165 return CXChildVisit_Continue; // it's not a function macro. 6166 6167 for (; CurIdx < NumTokens; ++CurIdx) { 6168 if (!SM.isBeforeInTranslationUnit(getTokenLoc(CurIdx), 6169 macroRange.getBegin())) 6170 break; 6171 } 6172 6173 if (CurIdx == NumTokens) 6174 return CXChildVisit_Break; 6175 6176 for (; CurIdx < NumTokens; ++CurIdx) { 6177 SourceLocation tokLoc = getTokenLoc(CurIdx); 6178 if (!SM.isBeforeInTranslationUnit(tokLoc, macroRange.getEnd())) 6179 break; 6180 6181 setFunctionMacroTokenLoc(CurIdx, SM.getMacroArgExpandedLocation(tokLoc)); 6182 } 6183 6184 if (CurIdx == NumTokens) 6185 return CXChildVisit_Break; 6186 6187 return CXChildVisit_Continue; 6188 } 6189 6190private: 6191 CXToken &getTok(unsigned Idx) { 6192 assert(Idx < NumTokens); 6193 return Tokens[Idx]; 6194 } 6195 const CXToken &getTok(unsigned Idx) const { 6196 assert(Idx < NumTokens); 6197 return Tokens[Idx]; 6198 } 6199 6200 SourceLocation getTokenLoc(unsigned tokI) { 6201 return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]); 6202 } 6203 6204 void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) { 6205 // The third field is reserved and currently not used. Use it here 6206 // to mark macro arg expanded tokens with their expanded locations. 6207 getTok(tokI).int_data[3] = loc.getRawEncoding(); 6208 } 6209}; 6210 6211} // end anonymous namespace 6212 6213static CXChildVisitResult 6214MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent, 6215 CXClientData client_data) { 6216 return static_cast<MarkMacroArgTokensVisitor*>(client_data)->visit(cursor, 6217 parent); 6218} 6219 6220/// \brief Used by \c annotatePreprocessorTokens. 6221/// \returns true if lexing was finished, false otherwise. 6222static bool lexNext(Lexer &Lex, Token &Tok, 6223 unsigned &NextIdx, unsigned NumTokens) { 6224 if (NextIdx >= NumTokens) 6225 return true; 6226 6227 ++NextIdx; 6228 Lex.LexFromRawLexer(Tok); 6229 if (Tok.is(tok::eof)) 6230 return true; 6231 6232 return false; 6233} 6234 6235static void annotatePreprocessorTokens(CXTranslationUnit TU, 6236 SourceRange RegionOfInterest, 6237 CXCursor *Cursors, 6238 CXToken *Tokens, 6239 unsigned NumTokens) { 6240 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 6241 6242 Preprocessor &PP = CXXUnit->getPreprocessor(); 6243 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 6244 std::pair<FileID, unsigned> BeginLocInfo 6245 = SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getBegin()); 6246 std::pair<FileID, unsigned> EndLocInfo 6247 = SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getEnd()); 6248 6249 if (BeginLocInfo.first != EndLocInfo.first) 6250 return; 6251 6252 StringRef Buffer; 6253 bool Invalid = false; 6254 Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid); 6255 if (Buffer.empty() || Invalid) 6256 return; 6257 6258 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 6259 CXXUnit->getASTContext().getLangOpts(), 6260 Buffer.begin(), Buffer.data() + BeginLocInfo.second, 6261 Buffer.end()); 6262 Lex.SetCommentRetentionState(true); 6263 6264 unsigned NextIdx = 0; 6265 // Lex tokens in raw mode until we hit the end of the range, to avoid 6266 // entering #includes or expanding macros. 6267 while (true) { 6268 Token Tok; 6269 if (lexNext(Lex, Tok, NextIdx, NumTokens)) 6270 break; 6271 unsigned TokIdx = NextIdx-1; 6272 assert(Tok.getLocation() == 6273 SourceLocation::getFromRawEncoding(Tokens[TokIdx].int_data[1])); 6274 6275 reprocess: 6276 if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) { 6277 // We have found a preprocessing directive. Annotate the tokens 6278 // appropriately. 6279 // 6280 // FIXME: Some simple tests here could identify macro definitions and 6281 // #undefs, to provide specific cursor kinds for those. 6282 6283 SourceLocation BeginLoc = Tok.getLocation(); 6284 if (lexNext(Lex, Tok, NextIdx, NumTokens)) 6285 break; 6286 6287 MacroInfo *MI = nullptr; 6288 if (Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == "define") { 6289 if (lexNext(Lex, Tok, NextIdx, NumTokens)) 6290 break; 6291 6292 if (Tok.is(tok::raw_identifier)) { 6293 IdentifierInfo &II = 6294 PP.getIdentifierTable().get(Tok.getRawIdentifier()); 6295 SourceLocation MappedTokLoc = 6296 CXXUnit->mapLocationToPreamble(Tok.getLocation()); 6297 MI = getMacroInfo(II, MappedTokLoc, TU); 6298 } 6299 } 6300 6301 bool finished = false; 6302 do { 6303 if (lexNext(Lex, Tok, NextIdx, NumTokens)) { 6304 finished = true; 6305 break; 6306 } 6307 // If we are in a macro definition, check if the token was ever a 6308 // macro name and annotate it if that's the case. 6309 if (MI) { 6310 SourceLocation SaveLoc = Tok.getLocation(); 6311 Tok.setLocation(CXXUnit->mapLocationToPreamble(SaveLoc)); 6312 MacroDefinitionRecord *MacroDef = 6313 checkForMacroInMacroDefinition(MI, Tok, TU); 6314 Tok.setLocation(SaveLoc); 6315 if (MacroDef) 6316 Cursors[NextIdx - 1] = 6317 MakeMacroExpansionCursor(MacroDef, Tok.getLocation(), TU); 6318 } 6319 } while (!Tok.isAtStartOfLine()); 6320 6321 unsigned LastIdx = finished ? NextIdx-1 : NextIdx-2; 6322 assert(TokIdx <= LastIdx); 6323 SourceLocation EndLoc = 6324 SourceLocation::getFromRawEncoding(Tokens[LastIdx].int_data[1]); 6325 CXCursor Cursor = 6326 MakePreprocessingDirectiveCursor(SourceRange(BeginLoc, EndLoc), TU); 6327 6328 for (; TokIdx <= LastIdx; ++TokIdx) 6329 updateCursorAnnotation(Cursors[TokIdx], Cursor); 6330 6331 if (finished) 6332 break; 6333 goto reprocess; 6334 } 6335 } 6336} 6337 6338// This gets run a separate thread to avoid stack blowout. 6339static void clang_annotateTokensImpl(CXTranslationUnit TU, ASTUnit *CXXUnit, 6340 CXToken *Tokens, unsigned NumTokens, 6341 CXCursor *Cursors) { 6342 CIndexer *CXXIdx = TU->CIdx; 6343 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 6344 setThreadBackgroundPriority(); 6345 6346 // Determine the region of interest, which contains all of the tokens. 6347 SourceRange RegionOfInterest; 6348 RegionOfInterest.setBegin( 6349 cxloc::translateSourceLocation(clang_getTokenLocation(TU, Tokens[0]))); 6350 RegionOfInterest.setEnd( 6351 cxloc::translateSourceLocation(clang_getTokenLocation(TU, 6352 Tokens[NumTokens-1]))); 6353 6354 // Relex the tokens within the source range to look for preprocessing 6355 // directives. 6356 annotatePreprocessorTokens(TU, RegionOfInterest, Cursors, Tokens, NumTokens); 6357 6358 // If begin location points inside a macro argument, set it to the expansion 6359 // location so we can have the full context when annotating semantically. 6360 { 6361 SourceManager &SM = CXXUnit->getSourceManager(); 6362 SourceLocation Loc = 6363 SM.getMacroArgExpandedLocation(RegionOfInterest.getBegin()); 6364 if (Loc.isMacroID()) 6365 RegionOfInterest.setBegin(SM.getExpansionLoc(Loc)); 6366 } 6367 6368 if (CXXUnit->getPreprocessor().getPreprocessingRecord()) { 6369 // Search and mark tokens that are macro argument expansions. 6370 MarkMacroArgTokensVisitor Visitor(CXXUnit->getSourceManager(), 6371 Tokens, NumTokens); 6372 CursorVisitor MacroArgMarker(TU, 6373 MarkMacroArgTokensVisitorDelegate, &Visitor, 6374 /*VisitPreprocessorLast=*/true, 6375 /*VisitIncludedEntities=*/false, 6376 RegionOfInterest); 6377 MacroArgMarker.visitPreprocessedEntitiesInRegion(); 6378 } 6379 6380 // Annotate all of the source locations in the region of interest that map to 6381 // a specific cursor. 6382 AnnotateTokensWorker W(Tokens, Cursors, NumTokens, TU, RegionOfInterest); 6383 6384 // FIXME: We use a ridiculous stack size here because the data-recursion 6385 // algorithm uses a large stack frame than the non-data recursive version, 6386 // and AnnotationTokensWorker currently transforms the data-recursion 6387 // algorithm back into a traditional recursion by explicitly calling 6388 // VisitChildren(). We will need to remove this explicit recursive call. 6389 W.AnnotateTokens(); 6390 6391 // If we ran into any entities that involve context-sensitive keywords, 6392 // take another pass through the tokens to mark them as such. 6393 if (W.hasContextSensitiveKeywords()) { 6394 for (unsigned I = 0; I != NumTokens; ++I) { 6395 if (clang_getTokenKind(Tokens[I]) != CXToken_Identifier) 6396 continue; 6397 6398 if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) { 6399 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 6400 if (const ObjCPropertyDecl *Property 6401 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(Cursors[I]))) { 6402 if (Property->getPropertyAttributesAsWritten() != 0 && 6403 llvm::StringSwitch<bool>(II->getName()) 6404 .Case("readonly", true) 6405 .Case("assign", true) 6406 .Case("unsafe_unretained", true) 6407 .Case("readwrite", true) 6408 .Case("retain", true) 6409 .Case("copy", true) 6410 .Case("nonatomic", true) 6411 .Case("atomic", true) 6412 .Case("getter", true) 6413 .Case("setter", true) 6414 .Case("strong", true) 6415 .Case("weak", true) 6416 .Default(false)) 6417 Tokens[I].int_data[0] = CXToken_Keyword; 6418 } 6419 continue; 6420 } 6421 6422 if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl || 6423 Cursors[I].kind == CXCursor_ObjCClassMethodDecl) { 6424 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 6425 if (llvm::StringSwitch<bool>(II->getName()) 6426 .Case("in", true) 6427 .Case("out", true) 6428 .Case("inout", true) 6429 .Case("oneway", true) 6430 .Case("bycopy", true) 6431 .Case("byref", true) 6432 .Default(false)) 6433 Tokens[I].int_data[0] = CXToken_Keyword; 6434 continue; 6435 } 6436 6437 if (Cursors[I].kind == CXCursor_CXXFinalAttr || 6438 Cursors[I].kind == CXCursor_CXXOverrideAttr) { 6439 Tokens[I].int_data[0] = CXToken_Keyword; 6440 continue; 6441 } 6442 } 6443 } 6444} 6445 6446extern "C" { 6447 6448void clang_annotateTokens(CXTranslationUnit TU, 6449 CXToken *Tokens, unsigned NumTokens, 6450 CXCursor *Cursors) { 6451 if (isNotUsableTU(TU)) { 6452 LOG_BAD_TU(TU); 6453 return; 6454 } 6455 if (NumTokens == 0 || !Tokens || !Cursors) { 6456 LOG_FUNC_SECTION { *Log << "<null input>"; } 6457 return; 6458 } 6459 6460 LOG_FUNC_SECTION { 6461 *Log << TU << ' '; 6462 CXSourceLocation bloc = clang_getTokenLocation(TU, Tokens[0]); 6463 CXSourceLocation eloc = clang_getTokenLocation(TU, Tokens[NumTokens-1]); 6464 *Log << clang_getRange(bloc, eloc); 6465 } 6466 6467 // Any token we don't specifically annotate will have a NULL cursor. 6468 CXCursor C = clang_getNullCursor(); 6469 for (unsigned I = 0; I != NumTokens; ++I) 6470 Cursors[I] = C; 6471 6472 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 6473 if (!CXXUnit) 6474 return; 6475 6476 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 6477 6478 auto AnnotateTokensImpl = [=]() { 6479 clang_annotateTokensImpl(TU, CXXUnit, Tokens, NumTokens, Cursors); 6480 }; 6481 llvm::CrashRecoveryContext CRC; 6482 if (!RunSafely(CRC, AnnotateTokensImpl, GetSafetyThreadStackSize() * 2)) { 6483 fprintf(stderr, "libclang: crash detected while annotating tokens\n"); 6484 } 6485} 6486 6487} // end: extern "C" 6488 6489//===----------------------------------------------------------------------===// 6490// Operations for querying linkage of a cursor. 6491//===----------------------------------------------------------------------===// 6492 6493extern "C" { 6494CXLinkageKind clang_getCursorLinkage(CXCursor cursor) { 6495 if (!clang_isDeclaration(cursor.kind)) 6496 return CXLinkage_Invalid; 6497 6498 const Decl *D = cxcursor::getCursorDecl(cursor); 6499 if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D)) 6500 switch (ND->getLinkageInternal()) { 6501 case NoLinkage: 6502 case VisibleNoLinkage: return CXLinkage_NoLinkage; 6503 case InternalLinkage: return CXLinkage_Internal; 6504 case UniqueExternalLinkage: return CXLinkage_UniqueExternal; 6505 case ExternalLinkage: return CXLinkage_External; 6506 }; 6507 6508 return CXLinkage_Invalid; 6509} 6510} // end: extern "C" 6511 6512//===----------------------------------------------------------------------===// 6513// Operations for querying visibility of a cursor. 6514//===----------------------------------------------------------------------===// 6515 6516extern "C" { 6517CXVisibilityKind clang_getCursorVisibility(CXCursor cursor) { 6518 if (!clang_isDeclaration(cursor.kind)) 6519 return CXVisibility_Invalid; 6520 6521 const Decl *D = cxcursor::getCursorDecl(cursor); 6522 if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D)) 6523 switch (ND->getVisibility()) { 6524 case HiddenVisibility: return CXVisibility_Hidden; 6525 case ProtectedVisibility: return CXVisibility_Protected; 6526 case DefaultVisibility: return CXVisibility_Default; 6527 }; 6528 6529 return CXVisibility_Invalid; 6530} 6531} // end: extern "C" 6532 6533//===----------------------------------------------------------------------===// 6534// Operations for querying language of a cursor. 6535//===----------------------------------------------------------------------===// 6536 6537static CXLanguageKind getDeclLanguage(const Decl *D) { 6538 if (!D) 6539 return CXLanguage_C; 6540 6541 switch (D->getKind()) { 6542 default: 6543 break; 6544 case Decl::ImplicitParam: 6545 case Decl::ObjCAtDefsField: 6546 case Decl::ObjCCategory: 6547 case Decl::ObjCCategoryImpl: 6548 case Decl::ObjCCompatibleAlias: 6549 case Decl::ObjCImplementation: 6550 case Decl::ObjCInterface: 6551 case Decl::ObjCIvar: 6552 case Decl::ObjCMethod: 6553 case Decl::ObjCProperty: 6554 case Decl::ObjCPropertyImpl: 6555 case Decl::ObjCProtocol: 6556 case Decl::ObjCTypeParam: 6557 return CXLanguage_ObjC; 6558 case Decl::CXXConstructor: 6559 case Decl::CXXConversion: 6560 case Decl::CXXDestructor: 6561 case Decl::CXXMethod: 6562 case Decl::CXXRecord: 6563 case Decl::ClassTemplate: 6564 case Decl::ClassTemplatePartialSpecialization: 6565 case Decl::ClassTemplateSpecialization: 6566 case Decl::Friend: 6567 case Decl::FriendTemplate: 6568 case Decl::FunctionTemplate: 6569 case Decl::LinkageSpec: 6570 case Decl::Namespace: 6571 case Decl::NamespaceAlias: 6572 case Decl::NonTypeTemplateParm: 6573 case Decl::StaticAssert: 6574 case Decl::TemplateTemplateParm: 6575 case Decl::TemplateTypeParm: 6576 case Decl::UnresolvedUsingTypename: 6577 case Decl::UnresolvedUsingValue: 6578 case Decl::Using: 6579 case Decl::UsingDirective: 6580 case Decl::UsingShadow: 6581 return CXLanguage_CPlusPlus; 6582 } 6583 6584 return CXLanguage_C; 6585} 6586 6587extern "C" { 6588 6589static CXAvailabilityKind getCursorAvailabilityForDecl(const Decl *D) { 6590 if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted()) 6591 return CXAvailability_NotAvailable; 6592 6593 switch (D->getAvailability()) { 6594 case AR_Available: 6595 case AR_NotYetIntroduced: 6596 if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D)) 6597 return getCursorAvailabilityForDecl( 6598 cast<Decl>(EnumConst->getDeclContext())); 6599 return CXAvailability_Available; 6600 6601 case AR_Deprecated: 6602 return CXAvailability_Deprecated; 6603 6604 case AR_Unavailable: 6605 return CXAvailability_NotAvailable; 6606 } 6607 6608 llvm_unreachable("Unknown availability kind!"); 6609} 6610 6611enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) { 6612 if (clang_isDeclaration(cursor.kind)) 6613 if (const Decl *D = cxcursor::getCursorDecl(cursor)) 6614 return getCursorAvailabilityForDecl(D); 6615 6616 return CXAvailability_Available; 6617} 6618 6619static CXVersion convertVersion(VersionTuple In) { 6620 CXVersion Out = { -1, -1, -1 }; 6621 if (In.empty()) 6622 return Out; 6623 6624 Out.Major = In.getMajor(); 6625 6626 Optional<unsigned> Minor = In.getMinor(); 6627 if (Minor.hasValue()) 6628 Out.Minor = *Minor; 6629 else 6630 return Out; 6631 6632 Optional<unsigned> Subminor = In.getSubminor(); 6633 if (Subminor.hasValue()) 6634 Out.Subminor = *Subminor; 6635 6636 return Out; 6637} 6638 6639static int getCursorPlatformAvailabilityForDecl(const Decl *D, 6640 int *always_deprecated, 6641 CXString *deprecated_message, 6642 int *always_unavailable, 6643 CXString *unavailable_message, 6644 CXPlatformAvailability *availability, 6645 int availability_size) { 6646 bool HadAvailAttr = false; 6647 int N = 0; 6648 for (auto A : D->attrs()) { 6649 if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(A)) { 6650 HadAvailAttr = true; 6651 if (always_deprecated) 6652 *always_deprecated = 1; 6653 if (deprecated_message) { 6654 clang_disposeString(*deprecated_message); 6655 *deprecated_message = cxstring::createDup(Deprecated->getMessage()); 6656 } 6657 continue; 6658 } 6659 6660 if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(A)) { 6661 HadAvailAttr = true; 6662 if (always_unavailable) 6663 *always_unavailable = 1; 6664 if (unavailable_message) { 6665 clang_disposeString(*unavailable_message); 6666 *unavailable_message = cxstring::createDup(Unavailable->getMessage()); 6667 } 6668 continue; 6669 } 6670 6671 if (AvailabilityAttr *Avail = dyn_cast<AvailabilityAttr>(A)) { 6672 HadAvailAttr = true; 6673 if (N < availability_size) { 6674 availability[N].Platform 6675 = cxstring::createDup(Avail->getPlatform()->getName()); 6676 availability[N].Introduced = convertVersion(Avail->getIntroduced()); 6677 availability[N].Deprecated = convertVersion(Avail->getDeprecated()); 6678 availability[N].Obsoleted = convertVersion(Avail->getObsoleted()); 6679 availability[N].Unavailable = Avail->getUnavailable(); 6680 availability[N].Message = cxstring::createDup(Avail->getMessage()); 6681 } 6682 ++N; 6683 } 6684 } 6685 6686 if (!HadAvailAttr) 6687 if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D)) 6688 return getCursorPlatformAvailabilityForDecl( 6689 cast<Decl>(EnumConst->getDeclContext()), 6690 always_deprecated, 6691 deprecated_message, 6692 always_unavailable, 6693 unavailable_message, 6694 availability, 6695 availability_size); 6696 6697 return N; 6698} 6699 6700int clang_getCursorPlatformAvailability(CXCursor cursor, 6701 int *always_deprecated, 6702 CXString *deprecated_message, 6703 int *always_unavailable, 6704 CXString *unavailable_message, 6705 CXPlatformAvailability *availability, 6706 int availability_size) { 6707 if (always_deprecated) 6708 *always_deprecated = 0; 6709 if (deprecated_message) 6710 *deprecated_message = cxstring::createEmpty(); 6711 if (always_unavailable) 6712 *always_unavailable = 0; 6713 if (unavailable_message) 6714 *unavailable_message = cxstring::createEmpty(); 6715 6716 if (!clang_isDeclaration(cursor.kind)) 6717 return 0; 6718 6719 const Decl *D = cxcursor::getCursorDecl(cursor); 6720 if (!D) 6721 return 0; 6722 6723 return getCursorPlatformAvailabilityForDecl(D, always_deprecated, 6724 deprecated_message, 6725 always_unavailable, 6726 unavailable_message, 6727 availability, 6728 availability_size); 6729} 6730 6731void clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability) { 6732 clang_disposeString(availability->Platform); 6733 clang_disposeString(availability->Message); 6734} 6735 6736CXLanguageKind clang_getCursorLanguage(CXCursor cursor) { 6737 if (clang_isDeclaration(cursor.kind)) 6738 return getDeclLanguage(cxcursor::getCursorDecl(cursor)); 6739 6740 return CXLanguage_Invalid; 6741} 6742 6743 /// \brief If the given cursor is the "templated" declaration 6744 /// descibing a class or function template, return the class or 6745 /// function template. 6746static const Decl *maybeGetTemplateCursor(const Decl *D) { 6747 if (!D) 6748 return nullptr; 6749 6750 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 6751 if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate()) 6752 return FunTmpl; 6753 6754 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) 6755 if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate()) 6756 return ClassTmpl; 6757 6758 return D; 6759} 6760 6761 6762enum CX_StorageClass clang_Cursor_getStorageClass(CXCursor C) { 6763 StorageClass sc = SC_None; 6764 const Decl *D = getCursorDecl(C); 6765 if (D) { 6766 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 6767 sc = FD->getStorageClass(); 6768 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 6769 sc = VD->getStorageClass(); 6770 } else { 6771 return CX_SC_Invalid; 6772 } 6773 } else { 6774 return CX_SC_Invalid; 6775 } 6776 switch (sc) { 6777 case SC_None: 6778 return CX_SC_None; 6779 case SC_Extern: 6780 return CX_SC_Extern; 6781 case SC_Static: 6782 return CX_SC_Static; 6783 case SC_PrivateExtern: 6784 return CX_SC_PrivateExtern; 6785 case SC_Auto: 6786 return CX_SC_Auto; 6787 case SC_Register: 6788 return CX_SC_Register; 6789 } 6790 llvm_unreachable("Unhandled storage class!"); 6791} 6792 6793CXCursor clang_getCursorSemanticParent(CXCursor cursor) { 6794 if (clang_isDeclaration(cursor.kind)) { 6795 if (const Decl *D = getCursorDecl(cursor)) { 6796 const DeclContext *DC = D->getDeclContext(); 6797 if (!DC) 6798 return clang_getNullCursor(); 6799 6800 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 6801 getCursorTU(cursor)); 6802 } 6803 } 6804 6805 if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) { 6806 if (const Decl *D = getCursorDecl(cursor)) 6807 return MakeCXCursor(D, getCursorTU(cursor)); 6808 } 6809 6810 return clang_getNullCursor(); 6811} 6812 6813CXCursor clang_getCursorLexicalParent(CXCursor cursor) { 6814 if (clang_isDeclaration(cursor.kind)) { 6815 if (const Decl *D = getCursorDecl(cursor)) { 6816 const DeclContext *DC = D->getLexicalDeclContext(); 6817 if (!DC) 6818 return clang_getNullCursor(); 6819 6820 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 6821 getCursorTU(cursor)); 6822 } 6823 } 6824 6825 // FIXME: Note that we can't easily compute the lexical context of a 6826 // statement or expression, so we return nothing. 6827 return clang_getNullCursor(); 6828} 6829 6830CXFile clang_getIncludedFile(CXCursor cursor) { 6831 if (cursor.kind != CXCursor_InclusionDirective) 6832 return nullptr; 6833 6834 const InclusionDirective *ID = getCursorInclusionDirective(cursor); 6835 return const_cast<FileEntry *>(ID->getFile()); 6836} 6837 6838unsigned clang_Cursor_getObjCPropertyAttributes(CXCursor C, unsigned reserved) { 6839 if (C.kind != CXCursor_ObjCPropertyDecl) 6840 return CXObjCPropertyAttr_noattr; 6841 6842 unsigned Result = CXObjCPropertyAttr_noattr; 6843 const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(getCursorDecl(C)); 6844 ObjCPropertyDecl::PropertyAttributeKind Attr = 6845 PD->getPropertyAttributesAsWritten(); 6846 6847#define SET_CXOBJCPROP_ATTR(A) \ 6848 if (Attr & ObjCPropertyDecl::OBJC_PR_##A) \ 6849 Result |= CXObjCPropertyAttr_##A 6850 SET_CXOBJCPROP_ATTR(readonly); 6851 SET_CXOBJCPROP_ATTR(getter); 6852 SET_CXOBJCPROP_ATTR(assign); 6853 SET_CXOBJCPROP_ATTR(readwrite); 6854 SET_CXOBJCPROP_ATTR(retain); 6855 SET_CXOBJCPROP_ATTR(copy); 6856 SET_CXOBJCPROP_ATTR(nonatomic); 6857 SET_CXOBJCPROP_ATTR(setter); 6858 SET_CXOBJCPROP_ATTR(atomic); 6859 SET_CXOBJCPROP_ATTR(weak); 6860 SET_CXOBJCPROP_ATTR(strong); 6861 SET_CXOBJCPROP_ATTR(unsafe_unretained); 6862#undef SET_CXOBJCPROP_ATTR 6863 6864 return Result; 6865} 6866 6867unsigned clang_Cursor_getObjCDeclQualifiers(CXCursor C) { 6868 if (!clang_isDeclaration(C.kind)) 6869 return CXObjCDeclQualifier_None; 6870 6871 Decl::ObjCDeclQualifier QT = Decl::OBJC_TQ_None; 6872 const Decl *D = getCursorDecl(C); 6873 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 6874 QT = MD->getObjCDeclQualifier(); 6875 else if (const ParmVarDecl *PD = dyn_cast<ParmVarDecl>(D)) 6876 QT = PD->getObjCDeclQualifier(); 6877 if (QT == Decl::OBJC_TQ_None) 6878 return CXObjCDeclQualifier_None; 6879 6880 unsigned Result = CXObjCDeclQualifier_None; 6881 if (QT & Decl::OBJC_TQ_In) Result |= CXObjCDeclQualifier_In; 6882 if (QT & Decl::OBJC_TQ_Inout) Result |= CXObjCDeclQualifier_Inout; 6883 if (QT & Decl::OBJC_TQ_Out) Result |= CXObjCDeclQualifier_Out; 6884 if (QT & Decl::OBJC_TQ_Bycopy) Result |= CXObjCDeclQualifier_Bycopy; 6885 if (QT & Decl::OBJC_TQ_Byref) Result |= CXObjCDeclQualifier_Byref; 6886 if (QT & Decl::OBJC_TQ_Oneway) Result |= CXObjCDeclQualifier_Oneway; 6887 6888 return Result; 6889} 6890 6891unsigned clang_Cursor_isObjCOptional(CXCursor C) { 6892 if (!clang_isDeclaration(C.kind)) 6893 return 0; 6894 6895 const Decl *D = getCursorDecl(C); 6896 if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) 6897 return PD->getPropertyImplementation() == ObjCPropertyDecl::Optional; 6898 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 6899 return MD->getImplementationControl() == ObjCMethodDecl::Optional; 6900 6901 return 0; 6902} 6903 6904unsigned clang_Cursor_isVariadic(CXCursor C) { 6905 if (!clang_isDeclaration(C.kind)) 6906 return 0; 6907 6908 const Decl *D = getCursorDecl(C); 6909 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 6910 return FD->isVariadic(); 6911 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 6912 return MD->isVariadic(); 6913 6914 return 0; 6915} 6916 6917CXSourceRange clang_Cursor_getCommentRange(CXCursor C) { 6918 if (!clang_isDeclaration(C.kind)) 6919 return clang_getNullRange(); 6920 6921 const Decl *D = getCursorDecl(C); 6922 ASTContext &Context = getCursorContext(C); 6923 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 6924 if (!RC) 6925 return clang_getNullRange(); 6926 6927 return cxloc::translateSourceRange(Context, RC->getSourceRange()); 6928} 6929 6930CXString clang_Cursor_getRawCommentText(CXCursor C) { 6931 if (!clang_isDeclaration(C.kind)) 6932 return cxstring::createNull(); 6933 6934 const Decl *D = getCursorDecl(C); 6935 ASTContext &Context = getCursorContext(C); 6936 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 6937 StringRef RawText = RC ? RC->getRawText(Context.getSourceManager()) : 6938 StringRef(); 6939 6940 // Don't duplicate the string because RawText points directly into source 6941 // code. 6942 return cxstring::createRef(RawText); 6943} 6944 6945CXString clang_Cursor_getBriefCommentText(CXCursor C) { 6946 if (!clang_isDeclaration(C.kind)) 6947 return cxstring::createNull(); 6948 6949 const Decl *D = getCursorDecl(C); 6950 const ASTContext &Context = getCursorContext(C); 6951 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 6952 6953 if (RC) { 6954 StringRef BriefText = RC->getBriefText(Context); 6955 6956 // Don't duplicate the string because RawComment ensures that this memory 6957 // will not go away. 6958 return cxstring::createRef(BriefText); 6959 } 6960 6961 return cxstring::createNull(); 6962} 6963 6964CXModule clang_Cursor_getModule(CXCursor C) { 6965 if (C.kind == CXCursor_ModuleImportDecl) { 6966 if (const ImportDecl *ImportD = 6967 dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) 6968 return ImportD->getImportedModule(); 6969 } 6970 6971 return nullptr; 6972} 6973 6974CXModule clang_getModuleForFile(CXTranslationUnit TU, CXFile File) { 6975 if (isNotUsableTU(TU)) { 6976 LOG_BAD_TU(TU); 6977 return nullptr; 6978 } 6979 if (!File) 6980 return nullptr; 6981 FileEntry *FE = static_cast<FileEntry *>(File); 6982 6983 ASTUnit &Unit = *cxtu::getASTUnit(TU); 6984 HeaderSearch &HS = Unit.getPreprocessor().getHeaderSearchInfo(); 6985 ModuleMap::KnownHeader Header = HS.findModuleForHeader(FE); 6986 6987 return Header.getModule(); 6988} 6989 6990CXFile clang_Module_getASTFile(CXModule CXMod) { 6991 if (!CXMod) 6992 return nullptr; 6993 Module *Mod = static_cast<Module*>(CXMod); 6994 return const_cast<FileEntry *>(Mod->getASTFile()); 6995} 6996 6997CXModule clang_Module_getParent(CXModule CXMod) { 6998 if (!CXMod) 6999 return nullptr; 7000 Module *Mod = static_cast<Module*>(CXMod); 7001 return Mod->Parent; 7002} 7003 7004CXString clang_Module_getName(CXModule CXMod) { 7005 if (!CXMod) 7006 return cxstring::createEmpty(); 7007 Module *Mod = static_cast<Module*>(CXMod); 7008 return cxstring::createDup(Mod->Name); 7009} 7010 7011CXString clang_Module_getFullName(CXModule CXMod) { 7012 if (!CXMod) 7013 return cxstring::createEmpty(); 7014 Module *Mod = static_cast<Module*>(CXMod); 7015 return cxstring::createDup(Mod->getFullModuleName()); 7016} 7017 7018int clang_Module_isSystem(CXModule CXMod) { 7019 if (!CXMod) 7020 return 0; 7021 Module *Mod = static_cast<Module*>(CXMod); 7022 return Mod->IsSystem; 7023} 7024 7025unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit TU, 7026 CXModule CXMod) { 7027 if (isNotUsableTU(TU)) { 7028 LOG_BAD_TU(TU); 7029 return 0; 7030 } 7031 if (!CXMod) 7032 return 0; 7033 Module *Mod = static_cast<Module*>(CXMod); 7034 FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager(); 7035 ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr); 7036 return TopHeaders.size(); 7037} 7038 7039CXFile clang_Module_getTopLevelHeader(CXTranslationUnit TU, 7040 CXModule CXMod, unsigned Index) { 7041 if (isNotUsableTU(TU)) { 7042 LOG_BAD_TU(TU); 7043 return nullptr; 7044 } 7045 if (!CXMod) 7046 return nullptr; 7047 Module *Mod = static_cast<Module*>(CXMod); 7048 FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager(); 7049 7050 ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr); 7051 if (Index < TopHeaders.size()) 7052 return const_cast<FileEntry *>(TopHeaders[Index]); 7053 7054 return nullptr; 7055} 7056 7057} // end: extern "C" 7058 7059//===----------------------------------------------------------------------===// 7060// C++ AST instrospection. 7061//===----------------------------------------------------------------------===// 7062 7063extern "C" { 7064unsigned clang_CXXField_isMutable(CXCursor C) { 7065 if (!clang_isDeclaration(C.kind)) 7066 return 0; 7067 7068 if (const auto D = cxcursor::getCursorDecl(C)) 7069 if (const auto FD = dyn_cast_or_null<FieldDecl>(D)) 7070 return FD->isMutable() ? 1 : 0; 7071 return 0; 7072} 7073 7074unsigned clang_CXXMethod_isPureVirtual(CXCursor C) { 7075 if (!clang_isDeclaration(C.kind)) 7076 return 0; 7077 7078 const Decl *D = cxcursor::getCursorDecl(C); 7079 const CXXMethodDecl *Method = 7080 D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr; 7081 return (Method && Method->isVirtual() && Method->isPure()) ? 1 : 0; 7082} 7083 7084unsigned clang_CXXMethod_isConst(CXCursor C) { 7085 if (!clang_isDeclaration(C.kind)) 7086 return 0; 7087 7088 const Decl *D = cxcursor::getCursorDecl(C); 7089 const CXXMethodDecl *Method = 7090 D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr; 7091 return (Method && (Method->getTypeQualifiers() & Qualifiers::Const)) ? 1 : 0; 7092} 7093 7094unsigned clang_CXXMethod_isStatic(CXCursor C) { 7095 if (!clang_isDeclaration(C.kind)) 7096 return 0; 7097 7098 const Decl *D = cxcursor::getCursorDecl(C); 7099 const CXXMethodDecl *Method = 7100 D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr; 7101 return (Method && Method->isStatic()) ? 1 : 0; 7102} 7103 7104unsigned clang_CXXMethod_isVirtual(CXCursor C) { 7105 if (!clang_isDeclaration(C.kind)) 7106 return 0; 7107 7108 const Decl *D = cxcursor::getCursorDecl(C); 7109 const CXXMethodDecl *Method = 7110 D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr; 7111 return (Method && Method->isVirtual()) ? 1 : 0; 7112} 7113} // end: extern "C" 7114 7115//===----------------------------------------------------------------------===// 7116// Attribute introspection. 7117//===----------------------------------------------------------------------===// 7118 7119extern "C" { 7120CXType clang_getIBOutletCollectionType(CXCursor C) { 7121 if (C.kind != CXCursor_IBOutletCollectionAttr) 7122 return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C)); 7123 7124 const IBOutletCollectionAttr *A = 7125 cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C)); 7126 7127 return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorTU(C)); 7128} 7129} // end: extern "C" 7130 7131//===----------------------------------------------------------------------===// 7132// Inspecting memory usage. 7133//===----------------------------------------------------------------------===// 7134 7135typedef std::vector<CXTUResourceUsageEntry> MemUsageEntries; 7136 7137static inline void createCXTUResourceUsageEntry(MemUsageEntries &entries, 7138 enum CXTUResourceUsageKind k, 7139 unsigned long amount) { 7140 CXTUResourceUsageEntry entry = { k, amount }; 7141 entries.push_back(entry); 7142} 7143 7144extern "C" { 7145 7146const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) { 7147 const char *str = ""; 7148 switch (kind) { 7149 case CXTUResourceUsage_AST: 7150 str = "ASTContext: expressions, declarations, and types"; 7151 break; 7152 case CXTUResourceUsage_Identifiers: 7153 str = "ASTContext: identifiers"; 7154 break; 7155 case CXTUResourceUsage_Selectors: 7156 str = "ASTContext: selectors"; 7157 break; 7158 case CXTUResourceUsage_GlobalCompletionResults: 7159 str = "Code completion: cached global results"; 7160 break; 7161 case CXTUResourceUsage_SourceManagerContentCache: 7162 str = "SourceManager: content cache allocator"; 7163 break; 7164 case CXTUResourceUsage_AST_SideTables: 7165 str = "ASTContext: side tables"; 7166 break; 7167 case CXTUResourceUsage_SourceManager_Membuffer_Malloc: 7168 str = "SourceManager: malloc'ed memory buffers"; 7169 break; 7170 case CXTUResourceUsage_SourceManager_Membuffer_MMap: 7171 str = "SourceManager: mmap'ed memory buffers"; 7172 break; 7173 case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc: 7174 str = "ExternalASTSource: malloc'ed memory buffers"; 7175 break; 7176 case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap: 7177 str = "ExternalASTSource: mmap'ed memory buffers"; 7178 break; 7179 case CXTUResourceUsage_Preprocessor: 7180 str = "Preprocessor: malloc'ed memory"; 7181 break; 7182 case CXTUResourceUsage_PreprocessingRecord: 7183 str = "Preprocessor: PreprocessingRecord"; 7184 break; 7185 case CXTUResourceUsage_SourceManager_DataStructures: 7186 str = "SourceManager: data structures and tables"; 7187 break; 7188 case CXTUResourceUsage_Preprocessor_HeaderSearch: 7189 str = "Preprocessor: header search tables"; 7190 break; 7191 } 7192 return str; 7193} 7194 7195CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU) { 7196 if (isNotUsableTU(TU)) { 7197 LOG_BAD_TU(TU); 7198 CXTUResourceUsage usage = { (void*) nullptr, 0, nullptr }; 7199 return usage; 7200 } 7201 7202 ASTUnit *astUnit = cxtu::getASTUnit(TU); 7203 std::unique_ptr<MemUsageEntries> entries(new MemUsageEntries()); 7204 ASTContext &astContext = astUnit->getASTContext(); 7205 7206 // How much memory is used by AST nodes and types? 7207 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST, 7208 (unsigned long) astContext.getASTAllocatedMemory()); 7209 7210 // How much memory is used by identifiers? 7211 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Identifiers, 7212 (unsigned long) astContext.Idents.getAllocator().getTotalMemory()); 7213 7214 // How much memory is used for selectors? 7215 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Selectors, 7216 (unsigned long) astContext.Selectors.getTotalMemory()); 7217 7218 // How much memory is used by ASTContext's side tables? 7219 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST_SideTables, 7220 (unsigned long) astContext.getSideTableAllocatedMemory()); 7221 7222 // How much memory is used for caching global code completion results? 7223 unsigned long completionBytes = 0; 7224 if (GlobalCodeCompletionAllocator *completionAllocator = 7225 astUnit->getCachedCompletionAllocator().get()) { 7226 completionBytes = completionAllocator->getTotalMemory(); 7227 } 7228 createCXTUResourceUsageEntry(*entries, 7229 CXTUResourceUsage_GlobalCompletionResults, 7230 completionBytes); 7231 7232 // How much memory is being used by SourceManager's content cache? 7233 createCXTUResourceUsageEntry(*entries, 7234 CXTUResourceUsage_SourceManagerContentCache, 7235 (unsigned long) astContext.getSourceManager().getContentCacheSize()); 7236 7237 // How much memory is being used by the MemoryBuffer's in SourceManager? 7238 const SourceManager::MemoryBufferSizes &srcBufs = 7239 astUnit->getSourceManager().getMemoryBufferSizes(); 7240 7241 createCXTUResourceUsageEntry(*entries, 7242 CXTUResourceUsage_SourceManager_Membuffer_Malloc, 7243 (unsigned long) srcBufs.malloc_bytes); 7244 createCXTUResourceUsageEntry(*entries, 7245 CXTUResourceUsage_SourceManager_Membuffer_MMap, 7246 (unsigned long) srcBufs.mmap_bytes); 7247 createCXTUResourceUsageEntry(*entries, 7248 CXTUResourceUsage_SourceManager_DataStructures, 7249 (unsigned long) astContext.getSourceManager() 7250 .getDataStructureSizes()); 7251 7252 // How much memory is being used by the ExternalASTSource? 7253 if (ExternalASTSource *esrc = astContext.getExternalSource()) { 7254 const ExternalASTSource::MemoryBufferSizes &sizes = 7255 esrc->getMemoryBufferSizes(); 7256 7257 createCXTUResourceUsageEntry(*entries, 7258 CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc, 7259 (unsigned long) sizes.malloc_bytes); 7260 createCXTUResourceUsageEntry(*entries, 7261 CXTUResourceUsage_ExternalASTSource_Membuffer_MMap, 7262 (unsigned long) sizes.mmap_bytes); 7263 } 7264 7265 // How much memory is being used by the Preprocessor? 7266 Preprocessor &pp = astUnit->getPreprocessor(); 7267 createCXTUResourceUsageEntry(*entries, 7268 CXTUResourceUsage_Preprocessor, 7269 pp.getTotalMemory()); 7270 7271 if (PreprocessingRecord *pRec = pp.getPreprocessingRecord()) { 7272 createCXTUResourceUsageEntry(*entries, 7273 CXTUResourceUsage_PreprocessingRecord, 7274 pRec->getTotalMemory()); 7275 } 7276 7277 createCXTUResourceUsageEntry(*entries, 7278 CXTUResourceUsage_Preprocessor_HeaderSearch, 7279 pp.getHeaderSearchInfo().getTotalMemory()); 7280 7281 CXTUResourceUsage usage = { (void*) entries.get(), 7282 (unsigned) entries->size(), 7283 !entries->empty() ? &(*entries)[0] : nullptr }; 7284 entries.release(); 7285 return usage; 7286} 7287 7288void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage) { 7289 if (usage.data) 7290 delete (MemUsageEntries*) usage.data; 7291} 7292 7293CXSourceRangeList *clang_getSkippedRanges(CXTranslationUnit TU, CXFile file) { 7294 CXSourceRangeList *skipped = new CXSourceRangeList; 7295 skipped->count = 0; 7296 skipped->ranges = nullptr; 7297 7298 if (isNotUsableTU(TU)) { 7299 LOG_BAD_TU(TU); 7300 return skipped; 7301 } 7302 7303 if (!file) 7304 return skipped; 7305 7306 ASTUnit *astUnit = cxtu::getASTUnit(TU); 7307 PreprocessingRecord *ppRec = astUnit->getPreprocessor().getPreprocessingRecord(); 7308 if (!ppRec) 7309 return skipped; 7310 7311 ASTContext &Ctx = astUnit->getASTContext(); 7312 SourceManager &sm = Ctx.getSourceManager(); 7313 FileEntry *fileEntry = static_cast<FileEntry *>(file); 7314 FileID wantedFileID = sm.translateFile(fileEntry); 7315 7316 const std::vector<SourceRange> &SkippedRanges = ppRec->getSkippedRanges(); 7317 std::vector<SourceRange> wantedRanges; 7318 for (std::vector<SourceRange>::const_iterator i = SkippedRanges.begin(), ei = SkippedRanges.end(); 7319 i != ei; ++i) { 7320 if (sm.getFileID(i->getBegin()) == wantedFileID || sm.getFileID(i->getEnd()) == wantedFileID) 7321 wantedRanges.push_back(*i); 7322 } 7323 7324 skipped->count = wantedRanges.size(); 7325 skipped->ranges = new CXSourceRange[skipped->count]; 7326 for (unsigned i = 0, ei = skipped->count; i != ei; ++i) 7327 skipped->ranges[i] = cxloc::translateSourceRange(Ctx, wantedRanges[i]); 7328 7329 return skipped; 7330} 7331 7332void clang_disposeSourceRangeList(CXSourceRangeList *ranges) { 7333 if (ranges) { 7334 delete[] ranges->ranges; 7335 delete ranges; 7336 } 7337} 7338 7339} // end extern "C" 7340 7341void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) { 7342 CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU); 7343 for (unsigned I = 0; I != Usage.numEntries; ++I) 7344 fprintf(stderr, " %s: %lu\n", 7345 clang_getTUResourceUsageName(Usage.entries[I].kind), 7346 Usage.entries[I].amount); 7347 7348 clang_disposeCXTUResourceUsage(Usage); 7349} 7350 7351//===----------------------------------------------------------------------===// 7352// Misc. utility functions. 7353//===----------------------------------------------------------------------===// 7354 7355/// Default to using an 8 MB stack size on "safety" threads. 7356static unsigned SafetyStackThreadSize = 8 << 20; 7357 7358namespace clang { 7359 7360bool RunSafely(llvm::CrashRecoveryContext &CRC, llvm::function_ref<void()> Fn, 7361 unsigned Size) { 7362 if (!Size) 7363 Size = GetSafetyThreadStackSize(); 7364 if (Size) 7365 return CRC.RunSafelyOnThread(Fn, Size); 7366 return CRC.RunSafely(Fn); 7367} 7368 7369unsigned GetSafetyThreadStackSize() { 7370 return SafetyStackThreadSize; 7371} 7372 7373void SetSafetyThreadStackSize(unsigned Value) { 7374 SafetyStackThreadSize = Value; 7375} 7376 7377} 7378 7379void clang::setThreadBackgroundPriority() { 7380 if (getenv("LIBCLANG_BGPRIO_DISABLE")) 7381 return; 7382 7383#ifdef USE_DARWIN_THREADS 7384 setpriority(PRIO_DARWIN_THREAD, 0, PRIO_DARWIN_BG); 7385#endif 7386} 7387 7388void cxindex::printDiagsToStderr(ASTUnit *Unit) { 7389 if (!Unit) 7390 return; 7391 7392 for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(), 7393 DEnd = Unit->stored_diag_end(); 7394 D != DEnd; ++D) { 7395 CXStoredDiagnostic Diag(*D, Unit->getLangOpts()); 7396 CXString Msg = clang_formatDiagnostic(&Diag, 7397 clang_defaultDiagnosticDisplayOptions()); 7398 fprintf(stderr, "%s\n", clang_getCString(Msg)); 7399 clang_disposeString(Msg); 7400 } 7401#ifdef LLVM_ON_WIN32 7402 // On Windows, force a flush, since there may be multiple copies of 7403 // stderr and stdout in the file system, all with different buffers 7404 // but writing to the same device. 7405 fflush(stderr); 7406#endif 7407} 7408 7409MacroInfo *cxindex::getMacroInfo(const IdentifierInfo &II, 7410 SourceLocation MacroDefLoc, 7411 CXTranslationUnit TU){ 7412 if (MacroDefLoc.isInvalid() || !TU) 7413 return nullptr; 7414 if (!II.hadMacroDefinition()) 7415 return nullptr; 7416 7417 ASTUnit *Unit = cxtu::getASTUnit(TU); 7418 Preprocessor &PP = Unit->getPreprocessor(); 7419 MacroDirective *MD = PP.getLocalMacroDirectiveHistory(&II); 7420 if (MD) { 7421 for (MacroDirective::DefInfo 7422 Def = MD->getDefinition(); Def; Def = Def.getPreviousDefinition()) { 7423 if (MacroDefLoc == Def.getMacroInfo()->getDefinitionLoc()) 7424 return Def.getMacroInfo(); 7425 } 7426 } 7427 7428 return nullptr; 7429} 7430 7431const MacroInfo *cxindex::getMacroInfo(const MacroDefinitionRecord *MacroDef, 7432 CXTranslationUnit TU) { 7433 if (!MacroDef || !TU) 7434 return nullptr; 7435 const IdentifierInfo *II = MacroDef->getName(); 7436 if (!II) 7437 return nullptr; 7438 7439 return getMacroInfo(*II, MacroDef->getLocation(), TU); 7440} 7441 7442MacroDefinitionRecord * 7443cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, const Token &Tok, 7444 CXTranslationUnit TU) { 7445 if (!MI || !TU) 7446 return nullptr; 7447 if (Tok.isNot(tok::raw_identifier)) 7448 return nullptr; 7449 7450 if (MI->getNumTokens() == 0) 7451 return nullptr; 7452 SourceRange DefRange(MI->getReplacementToken(0).getLocation(), 7453 MI->getDefinitionEndLoc()); 7454 ASTUnit *Unit = cxtu::getASTUnit(TU); 7455 7456 // Check that the token is inside the definition and not its argument list. 7457 SourceManager &SM = Unit->getSourceManager(); 7458 if (SM.isBeforeInTranslationUnit(Tok.getLocation(), DefRange.getBegin())) 7459 return nullptr; 7460 if (SM.isBeforeInTranslationUnit(DefRange.getEnd(), Tok.getLocation())) 7461 return nullptr; 7462 7463 Preprocessor &PP = Unit->getPreprocessor(); 7464 PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); 7465 if (!PPRec) 7466 return nullptr; 7467 7468 IdentifierInfo &II = PP.getIdentifierTable().get(Tok.getRawIdentifier()); 7469 if (!II.hadMacroDefinition()) 7470 return nullptr; 7471 7472 // Check that the identifier is not one of the macro arguments. 7473 if (std::find(MI->arg_begin(), MI->arg_end(), &II) != MI->arg_end()) 7474 return nullptr; 7475 7476 MacroDirective *InnerMD = PP.getLocalMacroDirectiveHistory(&II); 7477 if (!InnerMD) 7478 return nullptr; 7479 7480 return PPRec->findMacroDefinition(InnerMD->getMacroInfo()); 7481} 7482 7483MacroDefinitionRecord * 7484cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, SourceLocation Loc, 7485 CXTranslationUnit TU) { 7486 if (Loc.isInvalid() || !MI || !TU) 7487 return nullptr; 7488 7489 if (MI->getNumTokens() == 0) 7490 return nullptr; 7491 ASTUnit *Unit = cxtu::getASTUnit(TU); 7492 Preprocessor &PP = Unit->getPreprocessor(); 7493 if (!PP.getPreprocessingRecord()) 7494 return nullptr; 7495 Loc = Unit->getSourceManager().getSpellingLoc(Loc); 7496 Token Tok; 7497 if (PP.getRawToken(Loc, Tok)) 7498 return nullptr; 7499 7500 return checkForMacroInMacroDefinition(MI, Tok, TU); 7501} 7502 7503extern "C" { 7504 7505CXString clang_getClangVersion() { 7506 return cxstring::createDup(getClangFullVersion()); 7507} 7508 7509} // end: extern "C" 7510 7511Logger &cxindex::Logger::operator<<(CXTranslationUnit TU) { 7512 if (TU) { 7513 if (ASTUnit *Unit = cxtu::getASTUnit(TU)) { 7514 LogOS << '<' << Unit->getMainFileName() << '>'; 7515 if (Unit->isMainFileAST()) 7516 LogOS << " (" << Unit->getASTFileName() << ')'; 7517 return *this; 7518 } 7519 } else { 7520 LogOS << "<NULL TU>"; 7521 } 7522 return *this; 7523} 7524 7525Logger &cxindex::Logger::operator<<(const FileEntry *FE) { 7526 *this << FE->getName(); 7527 return *this; 7528} 7529 7530Logger &cxindex::Logger::operator<<(CXCursor cursor) { 7531 CXString cursorName = clang_getCursorDisplayName(cursor); 7532 *this << cursorName << "@" << clang_getCursorLocation(cursor); 7533 clang_disposeString(cursorName); 7534 return *this; 7535} 7536 7537Logger &cxindex::Logger::operator<<(CXSourceLocation Loc) { 7538 CXFile File; 7539 unsigned Line, Column; 7540 clang_getFileLocation(Loc, &File, &Line, &Column, nullptr); 7541 CXString FileName = clang_getFileName(File); 7542 *this << llvm::format("(%s:%d:%d)", clang_getCString(FileName), Line, Column); 7543 clang_disposeString(FileName); 7544 return *this; 7545} 7546 7547Logger &cxindex::Logger::operator<<(CXSourceRange range) { 7548 CXSourceLocation BLoc = clang_getRangeStart(range); 7549 CXSourceLocation ELoc = clang_getRangeEnd(range); 7550 7551 CXFile BFile; 7552 unsigned BLine, BColumn; 7553 clang_getFileLocation(BLoc, &BFile, &BLine, &BColumn, nullptr); 7554 7555 CXFile EFile; 7556 unsigned ELine, EColumn; 7557 clang_getFileLocation(ELoc, &EFile, &ELine, &EColumn, nullptr); 7558 7559 CXString BFileName = clang_getFileName(BFile); 7560 if (BFile == EFile) { 7561 *this << llvm::format("[%s %d:%d-%d:%d]", clang_getCString(BFileName), 7562 BLine, BColumn, ELine, EColumn); 7563 } else { 7564 CXString EFileName = clang_getFileName(EFile); 7565 *this << llvm::format("[%s:%d:%d - ", clang_getCString(BFileName), 7566 BLine, BColumn) 7567 << llvm::format("%s:%d:%d]", clang_getCString(EFileName), 7568 ELine, EColumn); 7569 clang_disposeString(EFileName); 7570 } 7571 clang_disposeString(BFileName); 7572 return *this; 7573} 7574 7575Logger &cxindex::Logger::operator<<(CXString Str) { 7576 *this << clang_getCString(Str); 7577 return *this; 7578} 7579 7580Logger &cxindex::Logger::operator<<(const llvm::format_object_base &Fmt) { 7581 LogOS << Fmt; 7582 return *this; 7583} 7584 7585static llvm::ManagedStatic<llvm::sys::Mutex> LoggingMutex; 7586 7587cxindex::Logger::~Logger() { 7588 llvm::sys::ScopedLock L(*LoggingMutex); 7589 7590 static llvm::TimeRecord sBeginTR = llvm::TimeRecord::getCurrentTime(); 7591 7592 raw_ostream &OS = llvm::errs(); 7593 OS << "[libclang:" << Name << ':'; 7594 7595#ifdef USE_DARWIN_THREADS 7596 // TODO: Portability. 7597 mach_port_t tid = pthread_mach_thread_np(pthread_self()); 7598 OS << tid << ':'; 7599#endif 7600 7601 llvm::TimeRecord TR = llvm::TimeRecord::getCurrentTime(); 7602 OS << llvm::format("%7.4f] ", TR.getWallTime() - sBeginTR.getWallTime()); 7603 OS << Msg << '\n'; 7604 7605 if (Trace) { 7606 llvm::sys::PrintStackTrace(OS); 7607 OS << "--------------------------------------------------\n"; 7608 } 7609} 7610