1//===- CIndex.cpp - Clang-C Source Indexing Library -----------------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file implements the main API hooks in the Clang-C Source Indexing 10// library. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CIndexDiagnostic.h" 15#include "CIndexer.h" 16#include "CLog.h" 17#include "CXCursor.h" 18#include "CXSourceLocation.h" 19#include "CXString.h" 20#include "CXTranslationUnit.h" 21#include "CXType.h" 22#include "CursorVisitor.h" 23#include "clang-c/FatalErrorHandler.h" 24#include "clang/AST/Attr.h" 25#include "clang/AST/DeclObjCCommon.h" 26#include "clang/AST/Mangle.h" 27#include "clang/AST/OpenMPClause.h" 28#include "clang/AST/StmtVisitor.h" 29#include "clang/Basic/Diagnostic.h" 30#include "clang/Basic/DiagnosticCategories.h" 31#include "clang/Basic/DiagnosticIDs.h" 32#include "clang/Basic/Stack.h" 33#include "clang/Basic/TargetInfo.h" 34#include "clang/Basic/Version.h" 35#include "clang/Frontend/ASTUnit.h" 36#include "clang/Frontend/CompilerInstance.h" 37#include "clang/Index/CommentToXML.h" 38#include "clang/Lex/HeaderSearch.h" 39#include "clang/Lex/Lexer.h" 40#include "clang/Lex/PreprocessingRecord.h" 41#include "clang/Lex/Preprocessor.h" 42#include "llvm/ADT/STLExtras.h" 43#include "llvm/ADT/StringSwitch.h" 44#include "llvm/Config/llvm-config.h" 45#include "llvm/Support/Compiler.h" 46#include "llvm/Support/CrashRecoveryContext.h" 47#include "llvm/Support/Format.h" 48#include "llvm/Support/ManagedStatic.h" 49#include "llvm/Support/MemoryBuffer.h" 50#include "llvm/Support/Program.h" 51#include "llvm/Support/SaveAndRestore.h" 52#include "llvm/Support/Signals.h" 53#include "llvm/Support/TargetSelect.h" 54#include "llvm/Support/Threading.h" 55#include "llvm/Support/Timer.h" 56#include "llvm/Support/raw_ostream.h" 57#include "llvm/Support/thread.h" 58#include <mutex> 59#include <optional> 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, 75 std::unique_ptr<ASTUnit> AU) { 76 if (!AU) 77 return nullptr; 78 assert(CIdx); 79 CXTranslationUnit D = new CXTranslationUnitImpl(); 80 D->CIdx = CIdx; 81 D->TheASTUnit = AU.release(); 82 D->StringPool = new cxstring::CXStringPool(); 83 D->Diagnostics = nullptr; 84 D->OverridenCursorsPool = createOverridenCXCursorsPool(); 85 D->CommentToXML = nullptr; 86 D->ParsingOptions = 0; 87 D->Arguments = {}; 88 return D; 89} 90 91bool cxtu::isASTReadError(ASTUnit *AU) { 92 for (ASTUnit::stored_diag_iterator D = AU->stored_diag_begin(), 93 DEnd = AU->stored_diag_end(); 94 D != DEnd; ++D) { 95 if (D->getLevel() >= DiagnosticsEngine::Error && 96 DiagnosticIDs::getCategoryNumberForDiag(D->getID()) == 97 diag::DiagCat_AST_Deserialization_Issue) 98 return true; 99 } 100 return false; 101} 102 103cxtu::CXTUOwner::~CXTUOwner() { 104 if (TU) 105 clang_disposeTranslationUnit(TU); 106} 107 108/// Compare two source ranges to determine their relative position in 109/// the translation unit. 110static RangeComparisonResult RangeCompare(SourceManager &SM, SourceRange R1, 111 SourceRange R2) { 112 assert(R1.isValid() && "First range is invalid?"); 113 assert(R2.isValid() && "Second range is invalid?"); 114 if (R1.getEnd() != R2.getBegin() && 115 SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin())) 116 return RangeBefore; 117 if (R2.getEnd() != R1.getBegin() && 118 SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin())) 119 return RangeAfter; 120 return RangeOverlap; 121} 122 123/// Determine if a source location falls within, before, or after a 124/// a given source range. 125static RangeComparisonResult LocationCompare(SourceManager &SM, 126 SourceLocation L, SourceRange R) { 127 assert(R.isValid() && "First range is invalid?"); 128 assert(L.isValid() && "Second range is invalid?"); 129 if (L == R.getBegin() || L == R.getEnd()) 130 return RangeOverlap; 131 if (SM.isBeforeInTranslationUnit(L, R.getBegin())) 132 return RangeBefore; 133 if (SM.isBeforeInTranslationUnit(R.getEnd(), L)) 134 return RangeAfter; 135 return RangeOverlap; 136} 137 138/// Translate a Clang source range into a CIndex source range. 139/// 140/// Clang internally represents ranges where the end location points to the 141/// start of the token at the end. However, for external clients it is more 142/// useful to have a CXSourceRange be a proper half-open interval. This routine 143/// does the appropriate translation. 144CXSourceRange cxloc::translateSourceRange(const SourceManager &SM, 145 const LangOptions &LangOpts, 146 const CharSourceRange &R) { 147 // We want the last character in this location, so we will adjust the 148 // location accordingly. 149 SourceLocation EndLoc = R.getEnd(); 150 bool IsTokenRange = R.isTokenRange(); 151 if (EndLoc.isValid() && EndLoc.isMacroID() && 152 !SM.isMacroArgExpansion(EndLoc)) { 153 CharSourceRange Expansion = SM.getExpansionRange(EndLoc); 154 EndLoc = Expansion.getEnd(); 155 IsTokenRange = Expansion.isTokenRange(); 156 } 157 if (IsTokenRange && EndLoc.isValid()) { 158 unsigned Length = 159 Lexer::MeasureTokenLength(SM.getSpellingLoc(EndLoc), SM, LangOpts); 160 EndLoc = EndLoc.getLocWithOffset(Length); 161 } 162 163 CXSourceRange Result = { 164 {&SM, &LangOpts}, R.getBegin().getRawEncoding(), EndLoc.getRawEncoding()}; 165 return Result; 166} 167 168CharSourceRange cxloc::translateCXRangeToCharRange(CXSourceRange R) { 169 return CharSourceRange::getCharRange( 170 SourceLocation::getFromRawEncoding(R.begin_int_data), 171 SourceLocation::getFromRawEncoding(R.end_int_data)); 172} 173 174//===----------------------------------------------------------------------===// 175// Cursor visitor. 176//===----------------------------------------------------------------------===// 177 178static SourceRange getRawCursorExtent(CXCursor C); 179static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr); 180 181RangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) { 182 return RangeCompare(AU->getSourceManager(), R, RegionOfInterest); 183} 184 185/// Visit the given cursor and, if requested by the visitor, 186/// its children. 187/// 188/// \param Cursor the cursor to visit. 189/// 190/// \param CheckedRegionOfInterest if true, then the caller already checked 191/// that this cursor is within the region of interest. 192/// 193/// \returns true if the visitation should be aborted, false if it 194/// should continue. 195bool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) { 196 if (clang_isInvalid(Cursor.kind)) 197 return false; 198 199 if (clang_isDeclaration(Cursor.kind)) { 200 const Decl *D = getCursorDecl(Cursor); 201 if (!D) { 202 assert(0 && "Invalid declaration cursor"); 203 return true; // abort. 204 } 205 206 // Ignore implicit declarations, unless it's an objc method because 207 // currently we should report implicit methods for properties when indexing. 208 if (D->isImplicit() && !isa<ObjCMethodDecl>(D)) 209 return false; 210 } 211 212 // If we have a range of interest, and this cursor doesn't intersect with it, 213 // we're done. 214 if (RegionOfInterest.isValid() && !CheckedRegionOfInterest) { 215 SourceRange Range = getRawCursorExtent(Cursor); 216 if (Range.isInvalid() || CompareRegionOfInterest(Range)) 217 return false; 218 } 219 220 switch (Visitor(Cursor, Parent, ClientData)) { 221 case CXChildVisit_Break: 222 return true; 223 224 case CXChildVisit_Continue: 225 return false; 226 227 case CXChildVisit_Recurse: { 228 bool ret = VisitChildren(Cursor); 229 if (PostChildrenVisitor) 230 if (PostChildrenVisitor(Cursor, ClientData)) 231 return true; 232 return ret; 233 } 234 } 235 236 llvm_unreachable("Invalid CXChildVisitResult!"); 237} 238 239static bool visitPreprocessedEntitiesInRange(SourceRange R, 240 PreprocessingRecord &PPRec, 241 CursorVisitor &Visitor) { 242 SourceManager &SM = Visitor.getASTUnit()->getSourceManager(); 243 FileID FID; 244 245 if (!Visitor.shouldVisitIncludedEntities()) { 246 // If the begin/end of the range lie in the same FileID, do the optimization 247 // where we skip preprocessed entities that do not come from the same 248 // FileID. 249 FID = SM.getFileID(SM.getFileLoc(R.getBegin())); 250 if (FID != SM.getFileID(SM.getFileLoc(R.getEnd()))) 251 FID = FileID(); 252 } 253 254 const auto &Entities = PPRec.getPreprocessedEntitiesInRange(R); 255 return Visitor.visitPreprocessedEntities(Entities.begin(), Entities.end(), 256 PPRec, FID); 257} 258 259bool CursorVisitor::visitFileRegion() { 260 if (RegionOfInterest.isInvalid()) 261 return false; 262 263 ASTUnit *Unit = cxtu::getASTUnit(TU); 264 SourceManager &SM = Unit->getSourceManager(); 265 266 std::pair<FileID, unsigned> Begin = SM.getDecomposedLoc( 267 SM.getFileLoc(RegionOfInterest.getBegin())), 268 End = SM.getDecomposedLoc( 269 SM.getFileLoc(RegionOfInterest.getEnd())); 270 271 if (End.first != Begin.first) { 272 // If the end does not reside in the same file, try to recover by 273 // picking the end of the file of begin location. 274 End.first = Begin.first; 275 End.second = SM.getFileIDSize(Begin.first); 276 } 277 278 assert(Begin.first == End.first); 279 if (Begin.second > End.second) 280 return false; 281 282 FileID File = Begin.first; 283 unsigned Offset = Begin.second; 284 unsigned Length = End.second - Begin.second; 285 286 if (!VisitDeclsOnly && !VisitPreprocessorLast) 287 if (visitPreprocessedEntitiesInRegion()) 288 return true; // visitation break. 289 290 if (visitDeclsFromFileRegion(File, Offset, Length)) 291 return true; // visitation break. 292 293 if (!VisitDeclsOnly && VisitPreprocessorLast) 294 return visitPreprocessedEntitiesInRegion(); 295 296 return false; 297} 298 299static bool isInLexicalContext(Decl *D, DeclContext *DC) { 300 if (!DC) 301 return false; 302 303 for (DeclContext *DeclDC = D->getLexicalDeclContext(); DeclDC; 304 DeclDC = DeclDC->getLexicalParent()) { 305 if (DeclDC == DC) 306 return true; 307 } 308 return false; 309} 310 311bool CursorVisitor::visitDeclsFromFileRegion(FileID File, unsigned Offset, 312 unsigned Length) { 313 ASTUnit *Unit = cxtu::getASTUnit(TU); 314 SourceManager &SM = Unit->getSourceManager(); 315 SourceRange Range = RegionOfInterest; 316 317 SmallVector<Decl *, 16> Decls; 318 Unit->findFileRegionDecls(File, Offset, Length, Decls); 319 320 // If we didn't find any file level decls for the file, try looking at the 321 // file that it was included from. 322 while (Decls.empty() || Decls.front()->isTopLevelDeclInObjCContainer()) { 323 bool Invalid = false; 324 const SrcMgr::SLocEntry &SLEntry = SM.getSLocEntry(File, &Invalid); 325 if (Invalid) 326 return false; 327 328 SourceLocation Outer; 329 if (SLEntry.isFile()) 330 Outer = SLEntry.getFile().getIncludeLoc(); 331 else 332 Outer = SLEntry.getExpansion().getExpansionLocStart(); 333 if (Outer.isInvalid()) 334 return false; 335 336 std::tie(File, Offset) = SM.getDecomposedExpansionLoc(Outer); 337 Length = 0; 338 Unit->findFileRegionDecls(File, Offset, Length, Decls); 339 } 340 341 assert(!Decls.empty()); 342 343 bool VisitedAtLeastOnce = false; 344 DeclContext *CurDC = nullptr; 345 SmallVectorImpl<Decl *>::iterator DIt = Decls.begin(); 346 for (SmallVectorImpl<Decl *>::iterator DE = Decls.end(); DIt != DE; ++DIt) { 347 Decl *D = *DIt; 348 if (D->getSourceRange().isInvalid()) 349 continue; 350 351 if (isInLexicalContext(D, CurDC)) 352 continue; 353 354 CurDC = dyn_cast<DeclContext>(D); 355 356 if (TagDecl *TD = dyn_cast<TagDecl>(D)) 357 if (!TD->isFreeStanding()) 358 continue; 359 360 RangeComparisonResult CompRes = 361 RangeCompare(SM, D->getSourceRange(), Range); 362 if (CompRes == RangeBefore) 363 continue; 364 if (CompRes == RangeAfter) 365 break; 366 367 assert(CompRes == RangeOverlap); 368 VisitedAtLeastOnce = true; 369 370 if (isa<ObjCContainerDecl>(D)) { 371 FileDI_current = &DIt; 372 FileDE_current = DE; 373 } else { 374 FileDI_current = nullptr; 375 } 376 377 if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true)) 378 return true; // visitation break. 379 } 380 381 if (VisitedAtLeastOnce) 382 return false; 383 384 // No Decls overlapped with the range. Move up the lexical context until there 385 // is a context that contains the range or we reach the translation unit 386 // level. 387 DeclContext *DC = DIt == Decls.begin() 388 ? (*DIt)->getLexicalDeclContext() 389 : (*(DIt - 1))->getLexicalDeclContext(); 390 391 while (DC && !DC->isTranslationUnit()) { 392 Decl *D = cast<Decl>(DC); 393 SourceRange CurDeclRange = D->getSourceRange(); 394 if (CurDeclRange.isInvalid()) 395 break; 396 397 if (RangeCompare(SM, CurDeclRange, Range) == RangeOverlap) { 398 if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true)) 399 return true; // visitation break. 400 } 401 402 DC = D->getLexicalDeclContext(); 403 } 404 405 return false; 406} 407 408bool CursorVisitor::visitPreprocessedEntitiesInRegion() { 409 if (!AU->getPreprocessor().getPreprocessingRecord()) 410 return false; 411 412 PreprocessingRecord &PPRec = *AU->getPreprocessor().getPreprocessingRecord(); 413 SourceManager &SM = AU->getSourceManager(); 414 415 if (RegionOfInterest.isValid()) { 416 SourceRange MappedRange = AU->mapRangeToPreamble(RegionOfInterest); 417 SourceLocation B = MappedRange.getBegin(); 418 SourceLocation E = MappedRange.getEnd(); 419 420 if (AU->isInPreambleFileID(B)) { 421 if (SM.isLoadedSourceLocation(E)) 422 return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec, 423 *this); 424 425 // Beginning of range lies in the preamble but it also extends beyond 426 // it into the main file. Split the range into 2 parts, one covering 427 // the preamble and another covering the main file. This allows subsequent 428 // calls to visitPreprocessedEntitiesInRange to accept a source range that 429 // lies in the same FileID, allowing it to skip preprocessed entities that 430 // do not come from the same FileID. 431 bool breaked = visitPreprocessedEntitiesInRange( 432 SourceRange(B, AU->getEndOfPreambleFileID()), PPRec, *this); 433 if (breaked) 434 return true; 435 return visitPreprocessedEntitiesInRange( 436 SourceRange(AU->getStartOfMainFileID(), E), PPRec, *this); 437 } 438 439 return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec, *this); 440 } 441 442 bool OnlyLocalDecls = !AU->isMainFileAST() && AU->getOnlyLocalDecls(); 443 444 if (OnlyLocalDecls) 445 return visitPreprocessedEntities(PPRec.local_begin(), PPRec.local_end(), 446 PPRec); 447 448 return visitPreprocessedEntities(PPRec.begin(), PPRec.end(), PPRec); 449} 450 451template <typename InputIterator> 452bool CursorVisitor::visitPreprocessedEntities(InputIterator First, 453 InputIterator Last, 454 PreprocessingRecord &PPRec, 455 FileID FID) { 456 for (; First != Last; ++First) { 457 if (!FID.isInvalid() && !PPRec.isEntityInFileID(First, FID)) 458 continue; 459 460 PreprocessedEntity *PPE = *First; 461 if (!PPE) 462 continue; 463 464 if (MacroExpansion *ME = dyn_cast<MacroExpansion>(PPE)) { 465 if (Visit(MakeMacroExpansionCursor(ME, TU))) 466 return true; 467 468 continue; 469 } 470 471 if (MacroDefinitionRecord *MD = dyn_cast<MacroDefinitionRecord>(PPE)) { 472 if (Visit(MakeMacroDefinitionCursor(MD, TU))) 473 return true; 474 475 continue; 476 } 477 478 if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) { 479 if (Visit(MakeInclusionDirectiveCursor(ID, TU))) 480 return true; 481 482 continue; 483 } 484 } 485 486 return false; 487} 488 489/// Visit the children of the given cursor. 490/// 491/// \returns true if the visitation should be aborted, false if it 492/// should continue. 493bool CursorVisitor::VisitChildren(CXCursor Cursor) { 494 if (clang_isReference(Cursor.kind) && 495 Cursor.kind != CXCursor_CXXBaseSpecifier) { 496 // By definition, references have no children. 497 return false; 498 } 499 500 // Set the Parent field to Cursor, then back to its old value once we're 501 // done. 502 SetParentRAII SetParent(Parent, StmtParent, Cursor); 503 504 if (clang_isDeclaration(Cursor.kind)) { 505 Decl *D = const_cast<Decl *>(getCursorDecl(Cursor)); 506 if (!D) 507 return false; 508 509 return VisitAttributes(D) || Visit(D); 510 } 511 512 if (clang_isStatement(Cursor.kind)) { 513 if (const Stmt *S = getCursorStmt(Cursor)) 514 return Visit(S); 515 516 return false; 517 } 518 519 if (clang_isExpression(Cursor.kind)) { 520 if (const Expr *E = getCursorExpr(Cursor)) 521 return Visit(E); 522 523 return false; 524 } 525 526 if (clang_isTranslationUnit(Cursor.kind)) { 527 CXTranslationUnit TU = getCursorTU(Cursor); 528 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 529 530 int VisitOrder[2] = {VisitPreprocessorLast, !VisitPreprocessorLast}; 531 for (unsigned I = 0; I != 2; ++I) { 532 if (VisitOrder[I]) { 533 if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() && 534 RegionOfInterest.isInvalid()) { 535 for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(), 536 TLEnd = CXXUnit->top_level_end(); 537 TL != TLEnd; ++TL) { 538 const std::optional<bool> V = handleDeclForVisitation(*TL); 539 if (!V) 540 continue; 541 return *V; 542 } 543 } else if (VisitDeclContext( 544 CXXUnit->getASTContext().getTranslationUnitDecl())) 545 return true; 546 continue; 547 } 548 549 // Walk the preprocessing record. 550 if (CXXUnit->getPreprocessor().getPreprocessingRecord()) 551 visitPreprocessedEntitiesInRegion(); 552 } 553 554 return false; 555 } 556 557 if (Cursor.kind == CXCursor_CXXBaseSpecifier) { 558 if (const CXXBaseSpecifier *Base = getCursorCXXBaseSpecifier(Cursor)) { 559 if (TypeSourceInfo *BaseTSInfo = Base->getTypeSourceInfo()) { 560 return Visit(BaseTSInfo->getTypeLoc()); 561 } 562 } 563 } 564 565 if (Cursor.kind == CXCursor_IBOutletCollectionAttr) { 566 const IBOutletCollectionAttr *A = 567 cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(Cursor)); 568 if (const ObjCObjectType *ObjT = A->getInterface()->getAs<ObjCObjectType>()) 569 return Visit(cxcursor::MakeCursorObjCClassRef( 570 ObjT->getInterface(), 571 A->getInterfaceLoc()->getTypeLoc().getBeginLoc(), TU)); 572 } 573 574 // If pointing inside a macro definition, check if the token is an identifier 575 // that was ever defined as a macro. In such a case, create a "pseudo" macro 576 // expansion cursor for that token. 577 SourceLocation BeginLoc = RegionOfInterest.getBegin(); 578 if (Cursor.kind == CXCursor_MacroDefinition && 579 BeginLoc == RegionOfInterest.getEnd()) { 580 SourceLocation Loc = AU->mapLocationToPreamble(BeginLoc); 581 const MacroInfo *MI = 582 getMacroInfo(cxcursor::getCursorMacroDefinition(Cursor), TU); 583 if (MacroDefinitionRecord *MacroDef = 584 checkForMacroInMacroDefinition(MI, Loc, TU)) 585 return Visit(cxcursor::MakeMacroExpansionCursor(MacroDef, BeginLoc, TU)); 586 } 587 588 // Nothing to visit at the moment. 589 return false; 590} 591 592bool CursorVisitor::VisitBlockDecl(BlockDecl *B) { 593 if (TypeSourceInfo *TSInfo = B->getSignatureAsWritten()) 594 if (Visit(TSInfo->getTypeLoc())) 595 return true; 596 597 if (Stmt *Body = B->getBody()) 598 return Visit(MakeCXCursor(Body, StmtParent, TU, RegionOfInterest)); 599 600 return false; 601} 602 603std::optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) { 604 if (RegionOfInterest.isValid()) { 605 SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager()); 606 if (Range.isInvalid()) 607 return std::nullopt; 608 609 switch (CompareRegionOfInterest(Range)) { 610 case RangeBefore: 611 // This declaration comes before the region of interest; skip it. 612 return std::nullopt; 613 614 case RangeAfter: 615 // This declaration comes after the region of interest; we're done. 616 return false; 617 618 case RangeOverlap: 619 // This declaration overlaps the region of interest; visit it. 620 break; 621 } 622 } 623 return true; 624} 625 626bool CursorVisitor::VisitDeclContext(DeclContext *DC) { 627 DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end(); 628 629 // FIXME: Eventually remove. This part of a hack to support proper 630 // iteration over all Decls contained lexically within an ObjC container. 631 SaveAndRestore DI_saved(DI_current, &I); 632 SaveAndRestore DE_saved(DE_current, E); 633 634 for (; I != E; ++I) { 635 Decl *D = *I; 636 if (D->getLexicalDeclContext() != DC) 637 continue; 638 // Filter out synthesized property accessor redeclarations. 639 if (isa<ObjCImplDecl>(DC)) 640 if (auto *OMD = dyn_cast<ObjCMethodDecl>(D)) 641 if (OMD->isSynthesizedAccessorStub()) 642 continue; 643 const std::optional<bool> V = handleDeclForVisitation(D); 644 if (!V) 645 continue; 646 return *V; 647 } 648 return false; 649} 650 651std::optional<bool> CursorVisitor::handleDeclForVisitation(const Decl *D) { 652 CXCursor Cursor = MakeCXCursor(D, TU, RegionOfInterest); 653 654 // Ignore synthesized ivars here, otherwise if we have something like: 655 // @synthesize prop = _prop; 656 // and '_prop' is not declared, we will encounter a '_prop' ivar before 657 // encountering the 'prop' synthesize declaration and we will think that 658 // we passed the region-of-interest. 659 if (auto *ivarD = dyn_cast<ObjCIvarDecl>(D)) { 660 if (ivarD->getSynthesize()) 661 return std::nullopt; 662 } 663 664 // FIXME: ObjCClassRef/ObjCProtocolRef for forward class/protocol 665 // declarations is a mismatch with the compiler semantics. 666 if (Cursor.kind == CXCursor_ObjCInterfaceDecl) { 667 auto *ID = cast<ObjCInterfaceDecl>(D); 668 if (!ID->isThisDeclarationADefinition()) 669 Cursor = MakeCursorObjCClassRef(ID, ID->getLocation(), TU); 670 671 } else if (Cursor.kind == CXCursor_ObjCProtocolDecl) { 672 auto *PD = cast<ObjCProtocolDecl>(D); 673 if (!PD->isThisDeclarationADefinition()) 674 Cursor = MakeCursorObjCProtocolRef(PD, PD->getLocation(), TU); 675 } 676 677 const std::optional<bool> V = shouldVisitCursor(Cursor); 678 if (!V) 679 return std::nullopt; 680 if (!*V) 681 return false; 682 if (Visit(Cursor, true)) 683 return true; 684 return std::nullopt; 685} 686 687bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 688 llvm_unreachable("Translation units are visited directly by Visit()"); 689} 690 691bool CursorVisitor::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { 692 if (VisitTemplateParameters(D->getTemplateParameters())) 693 return true; 694 695 return Visit(MakeCXCursor(D->getTemplatedDecl(), TU, RegionOfInterest)); 696} 697 698bool CursorVisitor::VisitTypeAliasDecl(TypeAliasDecl *D) { 699 if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo()) 700 return Visit(TSInfo->getTypeLoc()); 701 702 return false; 703} 704 705bool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) { 706 if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo()) 707 return Visit(TSInfo->getTypeLoc()); 708 709 return false; 710} 711 712bool CursorVisitor::VisitTagDecl(TagDecl *D) { return VisitDeclContext(D); } 713 714bool CursorVisitor::VisitClassTemplateSpecializationDecl( 715 ClassTemplateSpecializationDecl *D) { 716 bool ShouldVisitBody = false; 717 switch (D->getSpecializationKind()) { 718 case TSK_Undeclared: 719 case TSK_ImplicitInstantiation: 720 // Nothing to visit 721 return false; 722 723 case TSK_ExplicitInstantiationDeclaration: 724 case TSK_ExplicitInstantiationDefinition: 725 break; 726 727 case TSK_ExplicitSpecialization: 728 ShouldVisitBody = true; 729 break; 730 } 731 732 // Visit the template arguments used in the specialization. 733 if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) { 734 TypeLoc TL = SpecType->getTypeLoc(); 735 if (TemplateSpecializationTypeLoc TSTLoc = 736 TL.getAs<TemplateSpecializationTypeLoc>()) { 737 for (unsigned I = 0, N = TSTLoc.getNumArgs(); I != N; ++I) 738 if (VisitTemplateArgumentLoc(TSTLoc.getArgLoc(I))) 739 return true; 740 } 741 } 742 743 return ShouldVisitBody && VisitCXXRecordDecl(D); 744} 745 746bool CursorVisitor::VisitClassTemplatePartialSpecializationDecl( 747 ClassTemplatePartialSpecializationDecl *D) { 748 // FIXME: Visit the "outer" template parameter lists on the TagDecl 749 // before visiting these template parameters. 750 if (VisitTemplateParameters(D->getTemplateParameters())) 751 return true; 752 753 // Visit the partial specialization arguments. 754 const ASTTemplateArgumentListInfo *Info = D->getTemplateArgsAsWritten(); 755 const TemplateArgumentLoc *TemplateArgs = Info->getTemplateArgs(); 756 for (unsigned I = 0, N = Info->NumTemplateArgs; I != N; ++I) 757 if (VisitTemplateArgumentLoc(TemplateArgs[I])) 758 return true; 759 760 return VisitCXXRecordDecl(D); 761} 762 763bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 764 if (const auto *TC = D->getTypeConstraint()) { 765 if (VisitTypeConstraint(*TC)) 766 return true; 767 } 768 769 // Visit the default argument. 770 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 771 if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo()) 772 if (Visit(DefArg->getTypeLoc())) 773 return true; 774 775 return false; 776} 777 778bool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) { 779 if (Expr *Init = D->getInitExpr()) 780 return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest)); 781 return false; 782} 783 784bool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) { 785 unsigned NumParamList = DD->getNumTemplateParameterLists(); 786 for (unsigned i = 0; i < NumParamList; i++) { 787 TemplateParameterList *Params = DD->getTemplateParameterList(i); 788 if (VisitTemplateParameters(Params)) 789 return true; 790 } 791 792 if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo()) 793 if (Visit(TSInfo->getTypeLoc())) 794 return true; 795 796 // Visit the nested-name-specifier, if present. 797 if (NestedNameSpecifierLoc QualifierLoc = DD->getQualifierLoc()) 798 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 799 return true; 800 801 return false; 802} 803 804static bool HasTrailingReturnType(FunctionDecl *ND) { 805 const QualType Ty = ND->getType(); 806 if (const FunctionType *AFT = Ty->getAs<FunctionType>()) { 807 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(AFT)) 808 return FT->hasTrailingReturn(); 809 } 810 811 return false; 812} 813 814/// Compare two base or member initializers based on their source order. 815static int CompareCXXCtorInitializers(CXXCtorInitializer *const *X, 816 CXXCtorInitializer *const *Y) { 817 return (*X)->getSourceOrder() - (*Y)->getSourceOrder(); 818} 819 820bool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) { 821 unsigned NumParamList = ND->getNumTemplateParameterLists(); 822 for (unsigned i = 0; i < NumParamList; i++) { 823 TemplateParameterList *Params = ND->getTemplateParameterList(i); 824 if (VisitTemplateParameters(Params)) 825 return true; 826 } 827 828 if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) { 829 // Visit the function declaration's syntactic components in the order 830 // written. This requires a bit of work. 831 TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens(); 832 FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>(); 833 const bool HasTrailingRT = HasTrailingReturnType(ND); 834 835 // If we have a function declared directly (without the use of a typedef), 836 // visit just the return type. Otherwise, just visit the function's type 837 // now. 838 if ((FTL && !isa<CXXConversionDecl>(ND) && !HasTrailingRT && 839 Visit(FTL.getReturnLoc())) || 840 (!FTL && Visit(TL))) 841 return true; 842 843 // Visit the nested-name-specifier, if present. 844 if (NestedNameSpecifierLoc QualifierLoc = ND->getQualifierLoc()) 845 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 846 return true; 847 848 // Visit the declaration name. 849 if (!isa<CXXDestructorDecl>(ND)) 850 if (VisitDeclarationNameInfo(ND->getNameInfo())) 851 return true; 852 853 // FIXME: Visit explicitly-specified template arguments! 854 855 // Visit the function parameters, if we have a function type. 856 if (FTL && VisitFunctionTypeLoc(FTL, true)) 857 return true; 858 859 // Visit the function's trailing return type. 860 if (FTL && HasTrailingRT && Visit(FTL.getReturnLoc())) 861 return true; 862 863 // FIXME: Attributes? 864 } 865 866 if (auto *E = ND->getTrailingRequiresClause()) { 867 if (Visit(E)) 868 return true; 869 } 870 871 if (ND->doesThisDeclarationHaveABody() && !ND->isLateTemplateParsed()) { 872 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) { 873 // Find the initializers that were written in the source. 874 SmallVector<CXXCtorInitializer *, 4> WrittenInits; 875 for (auto *I : Constructor->inits()) { 876 if (!I->isWritten()) 877 continue; 878 879 WrittenInits.push_back(I); 880 } 881 882 // Sort the initializers in source order 883 llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(), 884 &CompareCXXCtorInitializers); 885 886 // Visit the initializers in source order 887 for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) { 888 CXXCtorInitializer *Init = WrittenInits[I]; 889 if (Init->isAnyMemberInitializer()) { 890 if (Visit(MakeCursorMemberRef(Init->getAnyMember(), 891 Init->getMemberLocation(), TU))) 892 return true; 893 } else if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) { 894 if (Visit(TInfo->getTypeLoc())) 895 return true; 896 } 897 898 // Visit the initializer value. 899 if (Expr *Initializer = Init->getInit()) 900 if (Visit(MakeCXCursor(Initializer, ND, TU, RegionOfInterest))) 901 return true; 902 } 903 } 904 905 if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest))) 906 return true; 907 } 908 909 return false; 910} 911 912bool CursorVisitor::VisitFieldDecl(FieldDecl *D) { 913 if (VisitDeclaratorDecl(D)) 914 return true; 915 916 if (Expr *BitWidth = D->getBitWidth()) 917 return Visit(MakeCXCursor(BitWidth, StmtParent, TU, RegionOfInterest)); 918 919 if (Expr *Init = D->getInClassInitializer()) 920 return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest)); 921 922 return false; 923} 924 925bool CursorVisitor::VisitVarDecl(VarDecl *D) { 926 if (VisitDeclaratorDecl(D)) 927 return true; 928 929 if (Expr *Init = D->getInit()) 930 return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest)); 931 932 return false; 933} 934 935bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 936 if (VisitDeclaratorDecl(D)) 937 return true; 938 939 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 940 if (Expr *DefArg = D->getDefaultArgument()) 941 return Visit(MakeCXCursor(DefArg, StmtParent, TU, RegionOfInterest)); 942 943 return false; 944} 945 946bool CursorVisitor::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 947 // FIXME: Visit the "outer" template parameter lists on the FunctionDecl 948 // before visiting these template parameters. 949 if (VisitTemplateParameters(D->getTemplateParameters())) 950 return true; 951 952 auto *FD = D->getTemplatedDecl(); 953 return VisitAttributes(FD) || VisitFunctionDecl(FD); 954} 955 956bool CursorVisitor::VisitClassTemplateDecl(ClassTemplateDecl *D) { 957 // FIXME: Visit the "outer" template parameter lists on the TagDecl 958 // before visiting these template parameters. 959 if (VisitTemplateParameters(D->getTemplateParameters())) 960 return true; 961 962 auto *CD = D->getTemplatedDecl(); 963 return VisitAttributes(CD) || VisitCXXRecordDecl(CD); 964} 965 966bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 967 if (VisitTemplateParameters(D->getTemplateParameters())) 968 return true; 969 970 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() && 971 VisitTemplateArgumentLoc(D->getDefaultArgument())) 972 return true; 973 974 return false; 975} 976 977bool CursorVisitor::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) { 978 // Visit the bound, if it's explicit. 979 if (D->hasExplicitBound()) { 980 if (auto TInfo = D->getTypeSourceInfo()) { 981 if (Visit(TInfo->getTypeLoc())) 982 return true; 983 } 984 } 985 986 return false; 987} 988 989bool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) { 990 if (TypeSourceInfo *TSInfo = ND->getReturnTypeSourceInfo()) 991 if (Visit(TSInfo->getTypeLoc())) 992 return true; 993 994 for (const auto *P : ND->parameters()) { 995 if (Visit(MakeCXCursor(P, TU, RegionOfInterest))) 996 return true; 997 } 998 999 return ND->isThisDeclarationADefinition() && 1000 Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest)); 1001} 1002 1003template <typename DeclIt> 1004static void addRangedDeclsInContainer(DeclIt *DI_current, DeclIt DE_current, 1005 SourceManager &SM, SourceLocation EndLoc, 1006 SmallVectorImpl<Decl *> &Decls) { 1007 DeclIt next = *DI_current; 1008 while (++next != DE_current) { 1009 Decl *D_next = *next; 1010 if (!D_next) 1011 break; 1012 SourceLocation L = D_next->getBeginLoc(); 1013 if (!L.isValid()) 1014 break; 1015 if (SM.isBeforeInTranslationUnit(L, EndLoc)) { 1016 *DI_current = next; 1017 Decls.push_back(D_next); 1018 continue; 1019 } 1020 break; 1021 } 1022} 1023 1024bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) { 1025 // FIXME: Eventually convert back to just 'VisitDeclContext()'. Essentially 1026 // an @implementation can lexically contain Decls that are not properly 1027 // nested in the AST. When we identify such cases, we need to retrofit 1028 // this nesting here. 1029 if (!DI_current && !FileDI_current) 1030 return VisitDeclContext(D); 1031 1032 // Scan the Decls that immediately come after the container 1033 // in the current DeclContext. If any fall within the 1034 // container's lexical region, stash them into a vector 1035 // for later processing. 1036 SmallVector<Decl *, 24> DeclsInContainer; 1037 SourceLocation EndLoc = D->getSourceRange().getEnd(); 1038 SourceManager &SM = AU->getSourceManager(); 1039 if (EndLoc.isValid()) { 1040 if (DI_current) { 1041 addRangedDeclsInContainer(DI_current, DE_current, SM, EndLoc, 1042 DeclsInContainer); 1043 } else { 1044 addRangedDeclsInContainer(FileDI_current, FileDE_current, SM, EndLoc, 1045 DeclsInContainer); 1046 } 1047 } 1048 1049 // The common case. 1050 if (DeclsInContainer.empty()) 1051 return VisitDeclContext(D); 1052 1053 // Get all the Decls in the DeclContext, and sort them with the 1054 // additional ones we've collected. Then visit them. 1055 for (auto *SubDecl : D->decls()) { 1056 if (!SubDecl || SubDecl->getLexicalDeclContext() != D || 1057 SubDecl->getBeginLoc().isInvalid()) 1058 continue; 1059 DeclsInContainer.push_back(SubDecl); 1060 } 1061 1062 // Now sort the Decls so that they appear in lexical order. 1063 llvm::sort(DeclsInContainer, [&SM](Decl *A, Decl *B) { 1064 SourceLocation L_A = A->getBeginLoc(); 1065 SourceLocation L_B = B->getBeginLoc(); 1066 return L_A != L_B 1067 ? SM.isBeforeInTranslationUnit(L_A, L_B) 1068 : SM.isBeforeInTranslationUnit(A->getEndLoc(), B->getEndLoc()); 1069 }); 1070 1071 // Now visit the decls. 1072 for (SmallVectorImpl<Decl *>::iterator I = DeclsInContainer.begin(), 1073 E = DeclsInContainer.end(); 1074 I != E; ++I) { 1075 CXCursor Cursor = MakeCXCursor(*I, TU, RegionOfInterest); 1076 const std::optional<bool> &V = shouldVisitCursor(Cursor); 1077 if (!V) 1078 continue; 1079 if (!*V) 1080 return false; 1081 if (Visit(Cursor, true)) 1082 return true; 1083 } 1084 return false; 1085} 1086 1087bool CursorVisitor::VisitObjCCategoryDecl(ObjCCategoryDecl *ND) { 1088 if (Visit(MakeCursorObjCClassRef(ND->getClassInterface(), ND->getLocation(), 1089 TU))) 1090 return true; 1091 1092 if (VisitObjCTypeParamList(ND->getTypeParamList())) 1093 return true; 1094 1095 ObjCCategoryDecl::protocol_loc_iterator PL = ND->protocol_loc_begin(); 1096 for (ObjCCategoryDecl::protocol_iterator I = ND->protocol_begin(), 1097 E = ND->protocol_end(); 1098 I != E; ++I, ++PL) 1099 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1100 return true; 1101 1102 return VisitObjCContainerDecl(ND); 1103} 1104 1105bool CursorVisitor::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) { 1106 if (!PID->isThisDeclarationADefinition()) 1107 return Visit(MakeCursorObjCProtocolRef(PID, PID->getLocation(), TU)); 1108 1109 ObjCProtocolDecl::protocol_loc_iterator PL = PID->protocol_loc_begin(); 1110 for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(), 1111 E = PID->protocol_end(); 1112 I != E; ++I, ++PL) 1113 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1114 return true; 1115 1116 return VisitObjCContainerDecl(PID); 1117} 1118 1119bool CursorVisitor::VisitObjCPropertyDecl(ObjCPropertyDecl *PD) { 1120 if (PD->getTypeSourceInfo() && Visit(PD->getTypeSourceInfo()->getTypeLoc())) 1121 return true; 1122 1123 // FIXME: This implements a workaround with @property declarations also being 1124 // installed in the DeclContext for the @interface. Eventually this code 1125 // should be removed. 1126 ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(PD->getDeclContext()); 1127 if (!CDecl || !CDecl->IsClassExtension()) 1128 return false; 1129 1130 ObjCInterfaceDecl *ID = CDecl->getClassInterface(); 1131 if (!ID) 1132 return false; 1133 1134 IdentifierInfo *PropertyId = PD->getIdentifier(); 1135 ObjCPropertyDecl *prevDecl = ObjCPropertyDecl::findPropertyDecl( 1136 cast<DeclContext>(ID), PropertyId, PD->getQueryKind()); 1137 1138 if (!prevDecl) 1139 return false; 1140 1141 // Visit synthesized methods since they will be skipped when visiting 1142 // the @interface. 1143 if (ObjCMethodDecl *MD = prevDecl->getGetterMethodDecl()) 1144 if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl) 1145 if (Visit(MakeCXCursor(MD, TU, RegionOfInterest))) 1146 return true; 1147 1148 if (ObjCMethodDecl *MD = prevDecl->getSetterMethodDecl()) 1149 if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl) 1150 if (Visit(MakeCXCursor(MD, TU, RegionOfInterest))) 1151 return true; 1152 1153 return false; 1154} 1155 1156bool CursorVisitor::VisitObjCTypeParamList(ObjCTypeParamList *typeParamList) { 1157 if (!typeParamList) 1158 return false; 1159 1160 for (auto *typeParam : *typeParamList) { 1161 // Visit the type parameter. 1162 if (Visit(MakeCXCursor(typeParam, TU, RegionOfInterest))) 1163 return true; 1164 } 1165 1166 return false; 1167} 1168 1169bool CursorVisitor::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 1170 if (!D->isThisDeclarationADefinition()) { 1171 // Forward declaration is treated like a reference. 1172 return Visit(MakeCursorObjCClassRef(D, D->getLocation(), TU)); 1173 } 1174 1175 // Objective-C type parameters. 1176 if (VisitObjCTypeParamList(D->getTypeParamListAsWritten())) 1177 return true; 1178 1179 // Issue callbacks for super class. 1180 if (D->getSuperClass() && Visit(MakeCursorObjCSuperClassRef( 1181 D->getSuperClass(), D->getSuperClassLoc(), TU))) 1182 return true; 1183 1184 if (TypeSourceInfo *SuperClassTInfo = D->getSuperClassTInfo()) 1185 if (Visit(SuperClassTInfo->getTypeLoc())) 1186 return true; 1187 1188 ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(); 1189 for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(), 1190 E = D->protocol_end(); 1191 I != E; ++I, ++PL) 1192 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1193 return true; 1194 1195 return VisitObjCContainerDecl(D); 1196} 1197 1198bool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) { 1199 return VisitObjCContainerDecl(D); 1200} 1201 1202bool CursorVisitor::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 1203 // 'ID' could be null when dealing with invalid code. 1204 if (ObjCInterfaceDecl *ID = D->getClassInterface()) 1205 if (Visit(MakeCursorObjCClassRef(ID, D->getLocation(), TU))) 1206 return true; 1207 1208 return VisitObjCImplDecl(D); 1209} 1210 1211bool CursorVisitor::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 1212#if 0 1213 // Issue callbacks for super class. 1214 // FIXME: No source location information! 1215 if (D->getSuperClass() && 1216 Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(), 1217 D->getSuperClassLoc(), 1218 TU))) 1219 return true; 1220#endif 1221 1222 return VisitObjCImplDecl(D); 1223} 1224 1225bool CursorVisitor::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD) { 1226 if (ObjCIvarDecl *Ivar = PD->getPropertyIvarDecl()) 1227 if (PD->isIvarNameSpecified()) 1228 return Visit(MakeCursorMemberRef(Ivar, PD->getPropertyIvarDeclLoc(), TU)); 1229 1230 return false; 1231} 1232 1233bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) { 1234 return VisitDeclContext(D); 1235} 1236 1237bool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 1238 // Visit nested-name-specifier. 1239 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1240 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1241 return true; 1242 1243 return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(), 1244 D->getTargetNameLoc(), TU)); 1245} 1246 1247bool CursorVisitor::VisitUsingDecl(UsingDecl *D) { 1248 // Visit nested-name-specifier. 1249 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) { 1250 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1251 return true; 1252 } 1253 1254 if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU))) 1255 return true; 1256 1257 return VisitDeclarationNameInfo(D->getNameInfo()); 1258} 1259 1260bool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 1261 // Visit nested-name-specifier. 1262 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1263 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1264 return true; 1265 1266 return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(), 1267 D->getIdentLocation(), TU)); 1268} 1269 1270bool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 1271 // Visit nested-name-specifier. 1272 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) { 1273 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1274 return true; 1275 } 1276 1277 return VisitDeclarationNameInfo(D->getNameInfo()); 1278} 1279 1280bool CursorVisitor::VisitUnresolvedUsingTypenameDecl( 1281 UnresolvedUsingTypenameDecl *D) { 1282 // Visit nested-name-specifier. 1283 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1284 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1285 return true; 1286 1287 return false; 1288} 1289 1290bool CursorVisitor::VisitStaticAssertDecl(StaticAssertDecl *D) { 1291 if (Visit(MakeCXCursor(D->getAssertExpr(), StmtParent, TU, RegionOfInterest))) 1292 return true; 1293 if (StringLiteral *Message = D->getMessage()) 1294 if (Visit(MakeCXCursor(Message, StmtParent, TU, RegionOfInterest))) 1295 return true; 1296 return false; 1297} 1298 1299bool CursorVisitor::VisitFriendDecl(FriendDecl *D) { 1300 if (NamedDecl *FriendD = D->getFriendDecl()) { 1301 if (Visit(MakeCXCursor(FriendD, TU, RegionOfInterest))) 1302 return true; 1303 } else if (TypeSourceInfo *TI = D->getFriendType()) { 1304 if (Visit(TI->getTypeLoc())) 1305 return true; 1306 } 1307 return false; 1308} 1309 1310bool CursorVisitor::VisitDecompositionDecl(DecompositionDecl *D) { 1311 for (auto *B : D->bindings()) { 1312 if (Visit(MakeCXCursor(B, TU, RegionOfInterest))) 1313 return true; 1314 } 1315 return VisitVarDecl(D); 1316} 1317 1318bool CursorVisitor::VisitConceptDecl(ConceptDecl *D) { 1319 if (VisitTemplateParameters(D->getTemplateParameters())) 1320 return true; 1321 1322 if (auto *E = D->getConstraintExpr()) { 1323 if (Visit(MakeCXCursor(E, D, TU, RegionOfInterest))) 1324 return true; 1325 } 1326 return false; 1327} 1328 1329bool CursorVisitor::VisitTypeConstraint(const TypeConstraint &TC) { 1330 if (TC.getNestedNameSpecifierLoc()) { 1331 if (VisitNestedNameSpecifierLoc(TC.getNestedNameSpecifierLoc())) 1332 return true; 1333 } 1334 if (TC.getNamedConcept()) { 1335 if (Visit(MakeCursorTemplateRef(TC.getNamedConcept(), 1336 TC.getConceptNameLoc(), TU))) 1337 return true; 1338 } 1339 if (auto Args = TC.getTemplateArgsAsWritten()) { 1340 for (const auto &Arg : Args->arguments()) { 1341 if (VisitTemplateArgumentLoc(Arg)) 1342 return true; 1343 } 1344 } 1345 return false; 1346} 1347 1348bool CursorVisitor::VisitConceptRequirement(const concepts::Requirement &R) { 1349 using namespace concepts; 1350 switch (R.getKind()) { 1351 case Requirement::RK_Type: { 1352 const TypeRequirement &TR = cast<TypeRequirement>(R); 1353 if (!TR.isSubstitutionFailure()) { 1354 if (Visit(TR.getType()->getTypeLoc())) 1355 return true; 1356 } 1357 break; 1358 } 1359 case Requirement::RK_Simple: 1360 case Requirement::RK_Compound: { 1361 const ExprRequirement &ER = cast<ExprRequirement>(R); 1362 if (!ER.isExprSubstitutionFailure()) { 1363 if (Visit(ER.getExpr())) 1364 return true; 1365 } 1366 if (ER.getKind() == Requirement::RK_Compound) { 1367 const auto &RTR = ER.getReturnTypeRequirement(); 1368 if (RTR.isTypeConstraint()) { 1369 if (const auto *Cons = RTR.getTypeConstraint()) 1370 VisitTypeConstraint(*Cons); 1371 } 1372 } 1373 break; 1374 } 1375 case Requirement::RK_Nested: { 1376 const NestedRequirement &NR = cast<NestedRequirement>(R); 1377 if (!NR.hasInvalidConstraint()) { 1378 if (Visit(NR.getConstraintExpr())) 1379 return true; 1380 } 1381 break; 1382 } 1383 } 1384 return false; 1385} 1386 1387bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) { 1388 switch (Name.getName().getNameKind()) { 1389 case clang::DeclarationName::Identifier: 1390 case clang::DeclarationName::CXXLiteralOperatorName: 1391 case clang::DeclarationName::CXXDeductionGuideName: 1392 case clang::DeclarationName::CXXOperatorName: 1393 case clang::DeclarationName::CXXUsingDirective: 1394 return false; 1395 1396 case clang::DeclarationName::CXXConstructorName: 1397 case clang::DeclarationName::CXXDestructorName: 1398 case clang::DeclarationName::CXXConversionFunctionName: 1399 if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo()) 1400 return Visit(TSInfo->getTypeLoc()); 1401 return false; 1402 1403 case clang::DeclarationName::ObjCZeroArgSelector: 1404 case clang::DeclarationName::ObjCOneArgSelector: 1405 case clang::DeclarationName::ObjCMultiArgSelector: 1406 // FIXME: Per-identifier location info? 1407 return false; 1408 } 1409 1410 llvm_unreachable("Invalid DeclarationName::Kind!"); 1411} 1412 1413bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS, 1414 SourceRange Range) { 1415 // FIXME: This whole routine is a hack to work around the lack of proper 1416 // source information in nested-name-specifiers (PR5791). Since we do have 1417 // a beginning source location, we can visit the first component of the 1418 // nested-name-specifier, if it's a single-token component. 1419 if (!NNS) 1420 return false; 1421 1422 // Get the first component in the nested-name-specifier. 1423 while (NestedNameSpecifier *Prefix = NNS->getPrefix()) 1424 NNS = Prefix; 1425 1426 switch (NNS->getKind()) { 1427 case NestedNameSpecifier::Namespace: 1428 return Visit( 1429 MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(), TU)); 1430 1431 case NestedNameSpecifier::NamespaceAlias: 1432 return Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 1433 Range.getBegin(), TU)); 1434 1435 case NestedNameSpecifier::TypeSpec: { 1436 // If the type has a form where we know that the beginning of the source 1437 // range matches up with a reference cursor. Visit the appropriate reference 1438 // cursor. 1439 const Type *T = NNS->getAsType(); 1440 if (const TypedefType *Typedef = dyn_cast<TypedefType>(T)) 1441 return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU)); 1442 if (const TagType *Tag = dyn_cast<TagType>(T)) 1443 return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU)); 1444 if (const TemplateSpecializationType *TST = 1445 dyn_cast<TemplateSpecializationType>(T)) 1446 return VisitTemplateName(TST->getTemplateName(), Range.getBegin()); 1447 break; 1448 } 1449 1450 case NestedNameSpecifier::TypeSpecWithTemplate: 1451 case NestedNameSpecifier::Global: 1452 case NestedNameSpecifier::Identifier: 1453 case NestedNameSpecifier::Super: 1454 break; 1455 } 1456 1457 return false; 1458} 1459 1460bool CursorVisitor::VisitNestedNameSpecifierLoc( 1461 NestedNameSpecifierLoc Qualifier) { 1462 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; 1463 for (; Qualifier; Qualifier = Qualifier.getPrefix()) 1464 Qualifiers.push_back(Qualifier); 1465 1466 while (!Qualifiers.empty()) { 1467 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val(); 1468 NestedNameSpecifier *NNS = Q.getNestedNameSpecifier(); 1469 switch (NNS->getKind()) { 1470 case NestedNameSpecifier::Namespace: 1471 if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), 1472 Q.getLocalBeginLoc(), TU))) 1473 return true; 1474 1475 break; 1476 1477 case NestedNameSpecifier::NamespaceAlias: 1478 if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 1479 Q.getLocalBeginLoc(), TU))) 1480 return true; 1481 1482 break; 1483 1484 case NestedNameSpecifier::TypeSpec: 1485 case NestedNameSpecifier::TypeSpecWithTemplate: 1486 if (Visit(Q.getTypeLoc())) 1487 return true; 1488 1489 break; 1490 1491 case NestedNameSpecifier::Global: 1492 case NestedNameSpecifier::Identifier: 1493 case NestedNameSpecifier::Super: 1494 break; 1495 } 1496 } 1497 1498 return false; 1499} 1500 1501bool CursorVisitor::VisitTemplateParameters( 1502 const TemplateParameterList *Params) { 1503 if (!Params) 1504 return false; 1505 1506 for (TemplateParameterList::const_iterator P = Params->begin(), 1507 PEnd = Params->end(); 1508 P != PEnd; ++P) { 1509 if (Visit(MakeCXCursor(*P, TU, RegionOfInterest))) 1510 return true; 1511 } 1512 1513 if (const auto *E = Params->getRequiresClause()) { 1514 if (Visit(MakeCXCursor(E, nullptr, TU, RegionOfInterest))) 1515 return true; 1516 } 1517 1518 return false; 1519} 1520 1521bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) { 1522 switch (Name.getKind()) { 1523 case TemplateName::Template: 1524 case TemplateName::UsingTemplate: 1525 case TemplateName::QualifiedTemplate: // FIXME: Visit nested-name-specifier. 1526 return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU)); 1527 1528 case TemplateName::OverloadedTemplate: 1529 // Visit the overloaded template set. 1530 if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU))) 1531 return true; 1532 1533 return false; 1534 1535 case TemplateName::AssumedTemplate: 1536 // FIXME: Visit DeclarationName? 1537 return false; 1538 1539 case TemplateName::DependentTemplate: 1540 // FIXME: Visit nested-name-specifier. 1541 return false; 1542 1543 case TemplateName::SubstTemplateTemplateParm: 1544 return Visit(MakeCursorTemplateRef( 1545 Name.getAsSubstTemplateTemplateParm()->getParameter(), Loc, TU)); 1546 1547 case TemplateName::SubstTemplateTemplateParmPack: 1548 return Visit(MakeCursorTemplateRef( 1549 Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(), Loc, 1550 TU)); 1551 } 1552 1553 llvm_unreachable("Invalid TemplateName::Kind!"); 1554} 1555 1556bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) { 1557 switch (TAL.getArgument().getKind()) { 1558 case TemplateArgument::Null: 1559 case TemplateArgument::Integral: 1560 case TemplateArgument::Pack: 1561 return false; 1562 1563 case TemplateArgument::Type: 1564 if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo()) 1565 return Visit(TSInfo->getTypeLoc()); 1566 return false; 1567 1568 case TemplateArgument::Declaration: 1569 if (Expr *E = TAL.getSourceDeclExpression()) 1570 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1571 return false; 1572 1573 case TemplateArgument::NullPtr: 1574 if (Expr *E = TAL.getSourceNullPtrExpression()) 1575 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1576 return false; 1577 1578 case TemplateArgument::Expression: 1579 if (Expr *E = TAL.getSourceExpression()) 1580 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1581 return false; 1582 1583 case TemplateArgument::Template: 1584 case TemplateArgument::TemplateExpansion: 1585 if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc())) 1586 return true; 1587 1588 return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(), 1589 TAL.getTemplateNameLoc()); 1590 } 1591 1592 llvm_unreachable("Invalid TemplateArgument::Kind!"); 1593} 1594 1595bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 1596 return VisitDeclContext(D); 1597} 1598 1599bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 1600 return Visit(TL.getUnqualifiedLoc()); 1601} 1602 1603bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 1604 ASTContext &Context = AU->getASTContext(); 1605 1606 // Some builtin types (such as Objective-C's "id", "sel", and 1607 // "Class") have associated declarations. Create cursors for those. 1608 QualType VisitType; 1609 switch (TL.getTypePtr()->getKind()) { 1610 1611 case BuiltinType::Void: 1612 case BuiltinType::NullPtr: 1613 case BuiltinType::Dependent: 1614#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 1615 case BuiltinType::Id: 1616#include "clang/Basic/OpenCLImageTypes.def" 1617#define EXT_OPAQUE_TYPE(ExtTYpe, Id, Ext) case BuiltinType::Id: 1618#include "clang/Basic/OpenCLExtensionTypes.def" 1619 case BuiltinType::OCLSampler: 1620 case BuiltinType::OCLEvent: 1621 case BuiltinType::OCLClkEvent: 1622 case BuiltinType::OCLQueue: 1623 case BuiltinType::OCLReserveID: 1624#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 1625#include "clang/Basic/AArch64SVEACLETypes.def" 1626#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id: 1627#include "clang/Basic/PPCTypes.def" 1628#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 1629#include "clang/Basic/RISCVVTypes.def" 1630#define BUILTIN_TYPE(Id, SingletonId) 1631#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: 1632#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: 1633#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id: 1634#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id: 1635#include "clang/AST/BuiltinTypes.def" 1636 break; 1637 1638 case BuiltinType::ObjCId: 1639 VisitType = Context.getObjCIdType(); 1640 break; 1641 1642 case BuiltinType::ObjCClass: 1643 VisitType = Context.getObjCClassType(); 1644 break; 1645 1646 case BuiltinType::ObjCSel: 1647 VisitType = Context.getObjCSelType(); 1648 break; 1649 } 1650 1651 if (!VisitType.isNull()) { 1652 if (const TypedefType *Typedef = VisitType->getAs<TypedefType>()) 1653 return Visit( 1654 MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(), TU)); 1655 } 1656 1657 return false; 1658} 1659 1660bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 1661 return Visit(MakeCursorTypeRef(TL.getTypedefNameDecl(), TL.getNameLoc(), TU)); 1662} 1663 1664bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 1665 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1666} 1667 1668bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) { 1669 if (TL.isDefinition()) 1670 return Visit(MakeCXCursor(TL.getDecl(), TU, RegionOfInterest)); 1671 1672 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1673} 1674 1675bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 1676 if (const auto *TC = TL.getDecl()->getTypeConstraint()) { 1677 if (VisitTypeConstraint(*TC)) 1678 return true; 1679 } 1680 1681 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1682} 1683 1684bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 1685 return Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU)); 1686} 1687 1688bool CursorVisitor::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) { 1689 if (Visit(MakeCursorTypeRef(TL.getDecl(), TL.getBeginLoc(), TU))) 1690 return true; 1691 for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) { 1692 if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I), 1693 TU))) 1694 return true; 1695 } 1696 1697 return false; 1698} 1699 1700bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 1701 if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc())) 1702 return true; 1703 1704 for (unsigned I = 0, N = TL.getNumTypeArgs(); I != N; ++I) { 1705 if (Visit(TL.getTypeArgTInfo(I)->getTypeLoc())) 1706 return true; 1707 } 1708 1709 for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) { 1710 if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I), 1711 TU))) 1712 return true; 1713 } 1714 1715 return false; 1716} 1717 1718bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 1719 return Visit(TL.getPointeeLoc()); 1720} 1721 1722bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) { 1723 return Visit(TL.getInnerLoc()); 1724} 1725 1726bool CursorVisitor::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) { 1727 return Visit(TL.getInnerLoc()); 1728} 1729 1730bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) { 1731 return Visit(TL.getPointeeLoc()); 1732} 1733 1734bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 1735 return Visit(TL.getPointeeLoc()); 1736} 1737 1738bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 1739 return Visit(TL.getPointeeLoc()); 1740} 1741 1742bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 1743 return Visit(TL.getPointeeLoc()); 1744} 1745 1746bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 1747 return Visit(TL.getPointeeLoc()); 1748} 1749 1750bool CursorVisitor::VisitUsingTypeLoc(UsingTypeLoc TL) { 1751 auto *underlyingDecl = TL.getUnderlyingType()->getAsTagDecl(); 1752 if (underlyingDecl) { 1753 return Visit(MakeCursorTypeRef(underlyingDecl, TL.getNameLoc(), TU)); 1754 } 1755 return false; 1756} 1757 1758bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 1759 return Visit(TL.getModifiedLoc()); 1760} 1761 1762bool CursorVisitor::VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) { 1763 return Visit(TL.getWrappedLoc()); 1764} 1765 1766bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL, 1767 bool SkipResultType) { 1768 if (!SkipResultType && Visit(TL.getReturnLoc())) 1769 return true; 1770 1771 for (unsigned I = 0, N = TL.getNumParams(); I != N; ++I) 1772 if (Decl *D = TL.getParam(I)) 1773 if (Visit(MakeCXCursor(D, TU, RegionOfInterest))) 1774 return true; 1775 1776 return false; 1777} 1778 1779bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) { 1780 if (Visit(TL.getElementLoc())) 1781 return true; 1782 1783 if (Expr *Size = TL.getSizeExpr()) 1784 return Visit(MakeCXCursor(Size, StmtParent, TU, RegionOfInterest)); 1785 1786 return false; 1787} 1788 1789bool CursorVisitor::VisitDecayedTypeLoc(DecayedTypeLoc TL) { 1790 return Visit(TL.getOriginalLoc()); 1791} 1792 1793bool CursorVisitor::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { 1794 return Visit(TL.getOriginalLoc()); 1795} 1796 1797bool CursorVisitor::VisitDeducedTemplateSpecializationTypeLoc( 1798 DeducedTemplateSpecializationTypeLoc TL) { 1799 if (VisitTemplateName(TL.getTypePtr()->getTemplateName(), 1800 TL.getTemplateNameLoc())) 1801 return true; 1802 1803 return false; 1804} 1805 1806bool CursorVisitor::VisitTemplateSpecializationTypeLoc( 1807 TemplateSpecializationTypeLoc TL) { 1808 // Visit the template name. 1809 if (VisitTemplateName(TL.getTypePtr()->getTemplateName(), 1810 TL.getTemplateNameLoc())) 1811 return true; 1812 1813 // Visit the template arguments. 1814 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1815 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1816 return true; 1817 1818 return false; 1819} 1820 1821bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 1822 return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU)); 1823} 1824 1825bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 1826 if (TypeSourceInfo *TSInfo = TL.getUnmodifiedTInfo()) 1827 return Visit(TSInfo->getTypeLoc()); 1828 1829 return false; 1830} 1831 1832bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 1833 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo()) 1834 return Visit(TSInfo->getTypeLoc()); 1835 1836 return false; 1837} 1838 1839bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 1840 return VisitNestedNameSpecifierLoc(TL.getQualifierLoc()); 1841} 1842 1843bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc( 1844 DependentTemplateSpecializationTypeLoc TL) { 1845 // Visit the nested-name-specifier, if there is one. 1846 if (TL.getQualifierLoc() && VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1847 return true; 1848 1849 // Visit the template arguments. 1850 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1851 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1852 return true; 1853 1854 return false; 1855} 1856 1857bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 1858 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1859 return true; 1860 1861 return Visit(TL.getNamedTypeLoc()); 1862} 1863 1864bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 1865 return Visit(TL.getPatternLoc()); 1866} 1867 1868bool CursorVisitor::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 1869 if (Expr *E = TL.getUnderlyingExpr()) 1870 return Visit(MakeCXCursor(E, StmtParent, TU)); 1871 1872 return false; 1873} 1874 1875bool CursorVisitor::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 1876 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1877} 1878 1879bool CursorVisitor::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 1880 return Visit(TL.getValueLoc()); 1881} 1882 1883bool CursorVisitor::VisitPipeTypeLoc(PipeTypeLoc TL) { 1884 return Visit(TL.getValueLoc()); 1885} 1886 1887#define DEFAULT_TYPELOC_IMPL(CLASS, PARENT) \ 1888 bool CursorVisitor::Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { \ 1889 return Visit##PARENT##Loc(TL); \ 1890 } 1891 1892DEFAULT_TYPELOC_IMPL(Complex, Type) 1893DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType) 1894DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType) 1895DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType) 1896DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType) 1897DEFAULT_TYPELOC_IMPL(DependentAddressSpace, Type) 1898DEFAULT_TYPELOC_IMPL(DependentVector, Type) 1899DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type) 1900DEFAULT_TYPELOC_IMPL(Vector, Type) 1901DEFAULT_TYPELOC_IMPL(ExtVector, VectorType) 1902DEFAULT_TYPELOC_IMPL(ConstantMatrix, MatrixType) 1903DEFAULT_TYPELOC_IMPL(DependentSizedMatrix, MatrixType) 1904DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType) 1905DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType) 1906DEFAULT_TYPELOC_IMPL(Record, TagType) 1907DEFAULT_TYPELOC_IMPL(Enum, TagType) 1908DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type) 1909DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type) 1910DEFAULT_TYPELOC_IMPL(Auto, Type) 1911DEFAULT_TYPELOC_IMPL(BitInt, Type) 1912DEFAULT_TYPELOC_IMPL(DependentBitInt, Type) 1913 1914bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) { 1915 // Visit the nested-name-specifier, if present. 1916 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1917 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1918 return true; 1919 1920 if (D->isCompleteDefinition()) { 1921 for (const auto &I : D->bases()) { 1922 if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(&I, TU))) 1923 return true; 1924 } 1925 } 1926 1927 return VisitTagDecl(D); 1928} 1929 1930bool CursorVisitor::VisitAttributes(Decl *D) { 1931 for (const auto *I : D->attrs()) 1932 if ((TU->ParsingOptions & CXTranslationUnit_VisitImplicitAttributes || 1933 !I->isImplicit()) && 1934 Visit(MakeCXCursor(I, D, TU))) 1935 return true; 1936 1937 return false; 1938} 1939 1940//===----------------------------------------------------------------------===// 1941// Data-recursive visitor methods. 1942//===----------------------------------------------------------------------===// 1943 1944namespace { 1945#define DEF_JOB(NAME, DATA, KIND) \ 1946 class NAME : public VisitorJob { \ 1947 public: \ 1948 NAME(const DATA *d, CXCursor parent) \ 1949 : VisitorJob(parent, VisitorJob::KIND, d) {} \ 1950 static bool classof(const VisitorJob *VJ) { \ 1951 return VJ->getKind() == KIND; \ 1952 } \ 1953 const DATA *get() const { return static_cast<const DATA *>(data[0]); } \ 1954 }; 1955 1956DEF_JOB(StmtVisit, Stmt, StmtVisitKind) 1957DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind) 1958DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind) 1959DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind) 1960DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind) 1961DEF_JOB(LambdaExprParts, LambdaExpr, LambdaExprPartsKind) 1962DEF_JOB(ConceptSpecializationExprVisit, ConceptSpecializationExpr, 1963 ConceptSpecializationExprVisitKind) 1964DEF_JOB(RequiresExprVisit, RequiresExpr, RequiresExprVisitKind) 1965DEF_JOB(PostChildrenVisit, void, PostChildrenVisitKind) 1966#undef DEF_JOB 1967 1968class ExplicitTemplateArgsVisit : public VisitorJob { 1969public: 1970 ExplicitTemplateArgsVisit(const TemplateArgumentLoc *Begin, 1971 const TemplateArgumentLoc *End, CXCursor parent) 1972 : VisitorJob(parent, VisitorJob::ExplicitTemplateArgsVisitKind, Begin, 1973 End) {} 1974 static bool classof(const VisitorJob *VJ) { 1975 return VJ->getKind() == ExplicitTemplateArgsVisitKind; 1976 } 1977 const TemplateArgumentLoc *begin() const { 1978 return static_cast<const TemplateArgumentLoc *>(data[0]); 1979 } 1980 const TemplateArgumentLoc *end() { 1981 return static_cast<const TemplateArgumentLoc *>(data[1]); 1982 } 1983}; 1984class DeclVisit : public VisitorJob { 1985public: 1986 DeclVisit(const Decl *D, CXCursor parent, bool isFirst) 1987 : VisitorJob(parent, VisitorJob::DeclVisitKind, D, 1988 isFirst ? (void *)1 : (void *)nullptr) {} 1989 static bool classof(const VisitorJob *VJ) { 1990 return VJ->getKind() == DeclVisitKind; 1991 } 1992 const Decl *get() const { return static_cast<const Decl *>(data[0]); } 1993 bool isFirst() const { return data[1] != nullptr; } 1994}; 1995class TypeLocVisit : public VisitorJob { 1996public: 1997 TypeLocVisit(TypeLoc tl, CXCursor parent) 1998 : VisitorJob(parent, VisitorJob::TypeLocVisitKind, 1999 tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {} 2000 2001 static bool classof(const VisitorJob *VJ) { 2002 return VJ->getKind() == TypeLocVisitKind; 2003 } 2004 2005 TypeLoc get() const { 2006 QualType T = QualType::getFromOpaquePtr(data[0]); 2007 return TypeLoc(T, const_cast<void *>(data[1])); 2008 } 2009}; 2010 2011class LabelRefVisit : public VisitorJob { 2012public: 2013 LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent) 2014 : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD, 2015 labelLoc.getPtrEncoding()) {} 2016 2017 static bool classof(const VisitorJob *VJ) { 2018 return VJ->getKind() == VisitorJob::LabelRefVisitKind; 2019 } 2020 const LabelDecl *get() const { 2021 return static_cast<const LabelDecl *>(data[0]); 2022 } 2023 SourceLocation getLoc() const { 2024 return SourceLocation::getFromPtrEncoding(data[1]); 2025 } 2026}; 2027 2028class NestedNameSpecifierLocVisit : public VisitorJob { 2029public: 2030 NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent) 2031 : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind, 2032 Qualifier.getNestedNameSpecifier(), 2033 Qualifier.getOpaqueData()) {} 2034 2035 static bool classof(const VisitorJob *VJ) { 2036 return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind; 2037 } 2038 2039 NestedNameSpecifierLoc get() const { 2040 return NestedNameSpecifierLoc( 2041 const_cast<NestedNameSpecifier *>( 2042 static_cast<const NestedNameSpecifier *>(data[0])), 2043 const_cast<void *>(data[1])); 2044 } 2045}; 2046 2047class DeclarationNameInfoVisit : public VisitorJob { 2048public: 2049 DeclarationNameInfoVisit(const Stmt *S, CXCursor parent) 2050 : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {} 2051 static bool classof(const VisitorJob *VJ) { 2052 return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind; 2053 } 2054 DeclarationNameInfo get() const { 2055 const Stmt *S = static_cast<const Stmt *>(data[0]); 2056 switch (S->getStmtClass()) { 2057 default: 2058 llvm_unreachable("Unhandled Stmt"); 2059 case clang::Stmt::MSDependentExistsStmtClass: 2060 return cast<MSDependentExistsStmt>(S)->getNameInfo(); 2061 case Stmt::CXXDependentScopeMemberExprClass: 2062 return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo(); 2063 case Stmt::DependentScopeDeclRefExprClass: 2064 return cast<DependentScopeDeclRefExpr>(S)->getNameInfo(); 2065 case Stmt::OMPCriticalDirectiveClass: 2066 return cast<OMPCriticalDirective>(S)->getDirectiveName(); 2067 } 2068 } 2069}; 2070class MemberRefVisit : public VisitorJob { 2071public: 2072 MemberRefVisit(const FieldDecl *D, SourceLocation L, CXCursor parent) 2073 : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D, 2074 L.getPtrEncoding()) {} 2075 static bool classof(const VisitorJob *VJ) { 2076 return VJ->getKind() == VisitorJob::MemberRefVisitKind; 2077 } 2078 const FieldDecl *get() const { 2079 return static_cast<const FieldDecl *>(data[0]); 2080 } 2081 SourceLocation getLoc() const { 2082 return SourceLocation::getFromRawEncoding( 2083 (SourceLocation::UIntTy)(uintptr_t)data[1]); 2084 } 2085}; 2086class EnqueueVisitor : public ConstStmtVisitor<EnqueueVisitor, void> { 2087 friend class OMPClauseEnqueue; 2088 VisitorWorkList &WL; 2089 CXCursor Parent; 2090 2091public: 2092 EnqueueVisitor(VisitorWorkList &wl, CXCursor parent) 2093 : WL(wl), Parent(parent) {} 2094 2095 void VisitAddrLabelExpr(const AddrLabelExpr *E); 2096 void VisitBlockExpr(const BlockExpr *B); 2097 void VisitCompoundLiteralExpr(const CompoundLiteralExpr *E); 2098 void VisitCompoundStmt(const CompoundStmt *S); 2099 void VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) { /* Do nothing. */ 2100 } 2101 void VisitMSDependentExistsStmt(const MSDependentExistsStmt *S); 2102 void VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E); 2103 void VisitCXXNewExpr(const CXXNewExpr *E); 2104 void VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E); 2105 void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *E); 2106 void VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E); 2107 void VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E); 2108 void VisitCXXTypeidExpr(const CXXTypeidExpr *E); 2109 void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *E); 2110 void VisitCXXUuidofExpr(const CXXUuidofExpr *E); 2111 void VisitCXXCatchStmt(const CXXCatchStmt *S); 2112 void VisitCXXForRangeStmt(const CXXForRangeStmt *S); 2113 void VisitDeclRefExpr(const DeclRefExpr *D); 2114 void VisitDeclStmt(const DeclStmt *S); 2115 void VisitDependentScopeDeclRefExpr(const DependentScopeDeclRefExpr *E); 2116 void VisitDesignatedInitExpr(const DesignatedInitExpr *E); 2117 void VisitExplicitCastExpr(const ExplicitCastExpr *E); 2118 void VisitForStmt(const ForStmt *FS); 2119 void VisitGotoStmt(const GotoStmt *GS); 2120 void VisitIfStmt(const IfStmt *If); 2121 void VisitInitListExpr(const InitListExpr *IE); 2122 void VisitMemberExpr(const MemberExpr *M); 2123 void VisitOffsetOfExpr(const OffsetOfExpr *E); 2124 void VisitObjCEncodeExpr(const ObjCEncodeExpr *E); 2125 void VisitObjCMessageExpr(const ObjCMessageExpr *M); 2126 void VisitOverloadExpr(const OverloadExpr *E); 2127 void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E); 2128 void VisitStmt(const Stmt *S); 2129 void VisitSwitchStmt(const SwitchStmt *S); 2130 void VisitWhileStmt(const WhileStmt *W); 2131 void VisitTypeTraitExpr(const TypeTraitExpr *E); 2132 void VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E); 2133 void VisitExpressionTraitExpr(const ExpressionTraitExpr *E); 2134 void VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U); 2135 void VisitVAArgExpr(const VAArgExpr *E); 2136 void VisitSizeOfPackExpr(const SizeOfPackExpr *E); 2137 void VisitPseudoObjectExpr(const PseudoObjectExpr *E); 2138 void VisitOpaqueValueExpr(const OpaqueValueExpr *E); 2139 void VisitLambdaExpr(const LambdaExpr *E); 2140 void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E); 2141 void VisitRequiresExpr(const RequiresExpr *E); 2142 void VisitCXXParenListInitExpr(const CXXParenListInitExpr *E); 2143 void VisitOMPExecutableDirective(const OMPExecutableDirective *D); 2144 void VisitOMPLoopBasedDirective(const OMPLoopBasedDirective *D); 2145 void VisitOMPLoopDirective(const OMPLoopDirective *D); 2146 void VisitOMPParallelDirective(const OMPParallelDirective *D); 2147 void VisitOMPSimdDirective(const OMPSimdDirective *D); 2148 void 2149 VisitOMPLoopTransformationDirective(const OMPLoopTransformationDirective *D); 2150 void VisitOMPTileDirective(const OMPTileDirective *D); 2151 void VisitOMPUnrollDirective(const OMPUnrollDirective *D); 2152 void VisitOMPForDirective(const OMPForDirective *D); 2153 void VisitOMPForSimdDirective(const OMPForSimdDirective *D); 2154 void VisitOMPSectionsDirective(const OMPSectionsDirective *D); 2155 void VisitOMPSectionDirective(const OMPSectionDirective *D); 2156 void VisitOMPSingleDirective(const OMPSingleDirective *D); 2157 void VisitOMPMasterDirective(const OMPMasterDirective *D); 2158 void VisitOMPCriticalDirective(const OMPCriticalDirective *D); 2159 void VisitOMPParallelForDirective(const OMPParallelForDirective *D); 2160 void VisitOMPParallelForSimdDirective(const OMPParallelForSimdDirective *D); 2161 void VisitOMPParallelMasterDirective(const OMPParallelMasterDirective *D); 2162 void VisitOMPParallelMaskedDirective(const OMPParallelMaskedDirective *D); 2163 void VisitOMPParallelSectionsDirective(const OMPParallelSectionsDirective *D); 2164 void VisitOMPTaskDirective(const OMPTaskDirective *D); 2165 void VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D); 2166 void VisitOMPBarrierDirective(const OMPBarrierDirective *D); 2167 void VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D); 2168 void VisitOMPErrorDirective(const OMPErrorDirective *D); 2169 void VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *D); 2170 void 2171 VisitOMPCancellationPointDirective(const OMPCancellationPointDirective *D); 2172 void VisitOMPCancelDirective(const OMPCancelDirective *D); 2173 void VisitOMPFlushDirective(const OMPFlushDirective *D); 2174 void VisitOMPDepobjDirective(const OMPDepobjDirective *D); 2175 void VisitOMPScanDirective(const OMPScanDirective *D); 2176 void VisitOMPOrderedDirective(const OMPOrderedDirective *D); 2177 void VisitOMPAtomicDirective(const OMPAtomicDirective *D); 2178 void VisitOMPTargetDirective(const OMPTargetDirective *D); 2179 void VisitOMPTargetDataDirective(const OMPTargetDataDirective *D); 2180 void VisitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective *D); 2181 void VisitOMPTargetExitDataDirective(const OMPTargetExitDataDirective *D); 2182 void VisitOMPTargetParallelDirective(const OMPTargetParallelDirective *D); 2183 void 2184 VisitOMPTargetParallelForDirective(const OMPTargetParallelForDirective *D); 2185 void VisitOMPTeamsDirective(const OMPTeamsDirective *D); 2186 void VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D); 2187 void VisitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective *D); 2188 void VisitOMPMasterTaskLoopDirective(const OMPMasterTaskLoopDirective *D); 2189 void VisitOMPMaskedTaskLoopDirective(const OMPMaskedTaskLoopDirective *D); 2190 void 2191 VisitOMPMasterTaskLoopSimdDirective(const OMPMasterTaskLoopSimdDirective *D); 2192 void VisitOMPMaskedTaskLoopSimdDirective( 2193 const OMPMaskedTaskLoopSimdDirective *D); 2194 void VisitOMPParallelMasterTaskLoopDirective( 2195 const OMPParallelMasterTaskLoopDirective *D); 2196 void VisitOMPParallelMaskedTaskLoopDirective( 2197 const OMPParallelMaskedTaskLoopDirective *D); 2198 void VisitOMPParallelMasterTaskLoopSimdDirective( 2199 const OMPParallelMasterTaskLoopSimdDirective *D); 2200 void VisitOMPParallelMaskedTaskLoopSimdDirective( 2201 const OMPParallelMaskedTaskLoopSimdDirective *D); 2202 void VisitOMPDistributeDirective(const OMPDistributeDirective *D); 2203 void VisitOMPDistributeParallelForDirective( 2204 const OMPDistributeParallelForDirective *D); 2205 void VisitOMPDistributeParallelForSimdDirective( 2206 const OMPDistributeParallelForSimdDirective *D); 2207 void VisitOMPDistributeSimdDirective(const OMPDistributeSimdDirective *D); 2208 void VisitOMPTargetParallelForSimdDirective( 2209 const OMPTargetParallelForSimdDirective *D); 2210 void VisitOMPTargetSimdDirective(const OMPTargetSimdDirective *D); 2211 void VisitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective *D); 2212 void VisitOMPTeamsDistributeSimdDirective( 2213 const OMPTeamsDistributeSimdDirective *D); 2214 void VisitOMPTeamsDistributeParallelForSimdDirective( 2215 const OMPTeamsDistributeParallelForSimdDirective *D); 2216 void VisitOMPTeamsDistributeParallelForDirective( 2217 const OMPTeamsDistributeParallelForDirective *D); 2218 void VisitOMPTargetTeamsDirective(const OMPTargetTeamsDirective *D); 2219 void VisitOMPTargetTeamsDistributeDirective( 2220 const OMPTargetTeamsDistributeDirective *D); 2221 void VisitOMPTargetTeamsDistributeParallelForDirective( 2222 const OMPTargetTeamsDistributeParallelForDirective *D); 2223 void VisitOMPTargetTeamsDistributeParallelForSimdDirective( 2224 const OMPTargetTeamsDistributeParallelForSimdDirective *D); 2225 void VisitOMPTargetTeamsDistributeSimdDirective( 2226 const OMPTargetTeamsDistributeSimdDirective *D); 2227 2228private: 2229 void AddDeclarationNameInfo(const Stmt *S); 2230 void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier); 2231 void AddExplicitTemplateArgs(const TemplateArgumentLoc *A, 2232 unsigned NumTemplateArgs); 2233 void AddMemberRef(const FieldDecl *D, SourceLocation L); 2234 void AddStmt(const Stmt *S); 2235 void AddDecl(const Decl *D, bool isFirst = true); 2236 void AddTypeLoc(TypeSourceInfo *TI); 2237 void EnqueueChildren(const Stmt *S); 2238 void EnqueueChildren(const OMPClause *S); 2239}; 2240} // namespace 2241 2242void EnqueueVisitor::AddDeclarationNameInfo(const Stmt *S) { 2243 // 'S' should always be non-null, since it comes from the 2244 // statement we are visiting. 2245 WL.push_back(DeclarationNameInfoVisit(S, Parent)); 2246} 2247 2248void EnqueueVisitor::AddNestedNameSpecifierLoc( 2249 NestedNameSpecifierLoc Qualifier) { 2250 if (Qualifier) 2251 WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent)); 2252} 2253 2254void EnqueueVisitor::AddStmt(const Stmt *S) { 2255 if (S) 2256 WL.push_back(StmtVisit(S, Parent)); 2257} 2258void EnqueueVisitor::AddDecl(const Decl *D, bool isFirst) { 2259 if (D) 2260 WL.push_back(DeclVisit(D, Parent, isFirst)); 2261} 2262void EnqueueVisitor::AddExplicitTemplateArgs(const TemplateArgumentLoc *A, 2263 unsigned NumTemplateArgs) { 2264 WL.push_back(ExplicitTemplateArgsVisit(A, A + NumTemplateArgs, Parent)); 2265} 2266void EnqueueVisitor::AddMemberRef(const FieldDecl *D, SourceLocation L) { 2267 if (D) 2268 WL.push_back(MemberRefVisit(D, L, Parent)); 2269} 2270void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) { 2271 if (TI) 2272 WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent)); 2273} 2274void EnqueueVisitor::EnqueueChildren(const Stmt *S) { 2275 unsigned size = WL.size(); 2276 for (const Stmt *SubStmt : S->children()) { 2277 AddStmt(SubStmt); 2278 } 2279 if (size == WL.size()) 2280 return; 2281 // Now reverse the entries we just added. This will match the DFS 2282 // ordering performed by the worklist. 2283 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 2284 std::reverse(I, E); 2285} 2286namespace { 2287class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> { 2288 EnqueueVisitor *Visitor; 2289 /// Process clauses with list of variables. 2290 template <typename T> void VisitOMPClauseList(T *Node); 2291 2292public: 2293 OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) {} 2294#define GEN_CLANG_CLAUSE_CLASS 2295#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C); 2296#include "llvm/Frontend/OpenMP/OMP.inc" 2297 void VisitOMPClauseWithPreInit(const OMPClauseWithPreInit *C); 2298 void VisitOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C); 2299}; 2300 2301void OMPClauseEnqueue::VisitOMPClauseWithPreInit( 2302 const OMPClauseWithPreInit *C) { 2303 Visitor->AddStmt(C->getPreInitStmt()); 2304} 2305 2306void OMPClauseEnqueue::VisitOMPClauseWithPostUpdate( 2307 const OMPClauseWithPostUpdate *C) { 2308 VisitOMPClauseWithPreInit(C); 2309 Visitor->AddStmt(C->getPostUpdateExpr()); 2310} 2311 2312void OMPClauseEnqueue::VisitOMPIfClause(const OMPIfClause *C) { 2313 VisitOMPClauseWithPreInit(C); 2314 Visitor->AddStmt(C->getCondition()); 2315} 2316 2317void OMPClauseEnqueue::VisitOMPFinalClause(const OMPFinalClause *C) { 2318 Visitor->AddStmt(C->getCondition()); 2319} 2320 2321void OMPClauseEnqueue::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) { 2322 VisitOMPClauseWithPreInit(C); 2323 Visitor->AddStmt(C->getNumThreads()); 2324} 2325 2326void OMPClauseEnqueue::VisitOMPSafelenClause(const OMPSafelenClause *C) { 2327 Visitor->AddStmt(C->getSafelen()); 2328} 2329 2330void OMPClauseEnqueue::VisitOMPSimdlenClause(const OMPSimdlenClause *C) { 2331 Visitor->AddStmt(C->getSimdlen()); 2332} 2333 2334void OMPClauseEnqueue::VisitOMPSizesClause(const OMPSizesClause *C) { 2335 for (auto E : C->getSizesRefs()) 2336 Visitor->AddStmt(E); 2337} 2338 2339void OMPClauseEnqueue::VisitOMPFullClause(const OMPFullClause *C) {} 2340 2341void OMPClauseEnqueue::VisitOMPPartialClause(const OMPPartialClause *C) { 2342 Visitor->AddStmt(C->getFactor()); 2343} 2344 2345void OMPClauseEnqueue::VisitOMPAllocatorClause(const OMPAllocatorClause *C) { 2346 Visitor->AddStmt(C->getAllocator()); 2347} 2348 2349void OMPClauseEnqueue::VisitOMPCollapseClause(const OMPCollapseClause *C) { 2350 Visitor->AddStmt(C->getNumForLoops()); 2351} 2352 2353void OMPClauseEnqueue::VisitOMPDefaultClause(const OMPDefaultClause *C) {} 2354 2355void OMPClauseEnqueue::VisitOMPProcBindClause(const OMPProcBindClause *C) {} 2356 2357void OMPClauseEnqueue::VisitOMPScheduleClause(const OMPScheduleClause *C) { 2358 VisitOMPClauseWithPreInit(C); 2359 Visitor->AddStmt(C->getChunkSize()); 2360} 2361 2362void OMPClauseEnqueue::VisitOMPOrderedClause(const OMPOrderedClause *C) { 2363 Visitor->AddStmt(C->getNumForLoops()); 2364} 2365 2366void OMPClauseEnqueue::VisitOMPDetachClause(const OMPDetachClause *C) { 2367 Visitor->AddStmt(C->getEventHandler()); 2368} 2369 2370void OMPClauseEnqueue::VisitOMPNowaitClause(const OMPNowaitClause *) {} 2371 2372void OMPClauseEnqueue::VisitOMPUntiedClause(const OMPUntiedClause *) {} 2373 2374void OMPClauseEnqueue::VisitOMPMergeableClause(const OMPMergeableClause *) {} 2375 2376void OMPClauseEnqueue::VisitOMPReadClause(const OMPReadClause *) {} 2377 2378void OMPClauseEnqueue::VisitOMPWriteClause(const OMPWriteClause *) {} 2379 2380void OMPClauseEnqueue::VisitOMPUpdateClause(const OMPUpdateClause *) {} 2381 2382void OMPClauseEnqueue::VisitOMPCaptureClause(const OMPCaptureClause *) {} 2383 2384void OMPClauseEnqueue::VisitOMPCompareClause(const OMPCompareClause *) {} 2385 2386void OMPClauseEnqueue::VisitOMPSeqCstClause(const OMPSeqCstClause *) {} 2387 2388void OMPClauseEnqueue::VisitOMPAcqRelClause(const OMPAcqRelClause *) {} 2389 2390void OMPClauseEnqueue::VisitOMPAcquireClause(const OMPAcquireClause *) {} 2391 2392void OMPClauseEnqueue::VisitOMPReleaseClause(const OMPReleaseClause *) {} 2393 2394void OMPClauseEnqueue::VisitOMPRelaxedClause(const OMPRelaxedClause *) {} 2395 2396void OMPClauseEnqueue::VisitOMPThreadsClause(const OMPThreadsClause *) {} 2397 2398void OMPClauseEnqueue::VisitOMPSIMDClause(const OMPSIMDClause *) {} 2399 2400void OMPClauseEnqueue::VisitOMPNogroupClause(const OMPNogroupClause *) {} 2401 2402void OMPClauseEnqueue::VisitOMPInitClause(const OMPInitClause *C) { 2403 VisitOMPClauseList(C); 2404} 2405 2406void OMPClauseEnqueue::VisitOMPUseClause(const OMPUseClause *C) { 2407 Visitor->AddStmt(C->getInteropVar()); 2408} 2409 2410void OMPClauseEnqueue::VisitOMPDestroyClause(const OMPDestroyClause *C) { 2411 if (C->getInteropVar()) 2412 Visitor->AddStmt(C->getInteropVar()); 2413} 2414 2415void OMPClauseEnqueue::VisitOMPNovariantsClause(const OMPNovariantsClause *C) { 2416 Visitor->AddStmt(C->getCondition()); 2417} 2418 2419void OMPClauseEnqueue::VisitOMPNocontextClause(const OMPNocontextClause *C) { 2420 Visitor->AddStmt(C->getCondition()); 2421} 2422 2423void OMPClauseEnqueue::VisitOMPFilterClause(const OMPFilterClause *C) { 2424 VisitOMPClauseWithPreInit(C); 2425 Visitor->AddStmt(C->getThreadID()); 2426} 2427 2428void OMPClauseEnqueue::VisitOMPAlignClause(const OMPAlignClause *C) { 2429 Visitor->AddStmt(C->getAlignment()); 2430} 2431 2432void OMPClauseEnqueue::VisitOMPUnifiedAddressClause( 2433 const OMPUnifiedAddressClause *) {} 2434 2435void OMPClauseEnqueue::VisitOMPUnifiedSharedMemoryClause( 2436 const OMPUnifiedSharedMemoryClause *) {} 2437 2438void OMPClauseEnqueue::VisitOMPReverseOffloadClause( 2439 const OMPReverseOffloadClause *) {} 2440 2441void OMPClauseEnqueue::VisitOMPDynamicAllocatorsClause( 2442 const OMPDynamicAllocatorsClause *) {} 2443 2444void OMPClauseEnqueue::VisitOMPAtomicDefaultMemOrderClause( 2445 const OMPAtomicDefaultMemOrderClause *) {} 2446 2447void OMPClauseEnqueue::VisitOMPAtClause(const OMPAtClause *) {} 2448 2449void OMPClauseEnqueue::VisitOMPSeverityClause(const OMPSeverityClause *) {} 2450 2451void OMPClauseEnqueue::VisitOMPMessageClause(const OMPMessageClause *) {} 2452 2453void OMPClauseEnqueue::VisitOMPDeviceClause(const OMPDeviceClause *C) { 2454 Visitor->AddStmt(C->getDevice()); 2455} 2456 2457void OMPClauseEnqueue::VisitOMPNumTeamsClause(const OMPNumTeamsClause *C) { 2458 VisitOMPClauseWithPreInit(C); 2459 Visitor->AddStmt(C->getNumTeams()); 2460} 2461 2462void OMPClauseEnqueue::VisitOMPThreadLimitClause( 2463 const OMPThreadLimitClause *C) { 2464 VisitOMPClauseWithPreInit(C); 2465 Visitor->AddStmt(C->getThreadLimit()); 2466} 2467 2468void OMPClauseEnqueue::VisitOMPPriorityClause(const OMPPriorityClause *C) { 2469 Visitor->AddStmt(C->getPriority()); 2470} 2471 2472void OMPClauseEnqueue::VisitOMPGrainsizeClause(const OMPGrainsizeClause *C) { 2473 Visitor->AddStmt(C->getGrainsize()); 2474} 2475 2476void OMPClauseEnqueue::VisitOMPNumTasksClause(const OMPNumTasksClause *C) { 2477 Visitor->AddStmt(C->getNumTasks()); 2478} 2479 2480void OMPClauseEnqueue::VisitOMPHintClause(const OMPHintClause *C) { 2481 Visitor->AddStmt(C->getHint()); 2482} 2483 2484template <typename T> void OMPClauseEnqueue::VisitOMPClauseList(T *Node) { 2485 for (const auto *I : Node->varlists()) { 2486 Visitor->AddStmt(I); 2487 } 2488} 2489 2490void OMPClauseEnqueue::VisitOMPInclusiveClause(const OMPInclusiveClause *C) { 2491 VisitOMPClauseList(C); 2492} 2493void OMPClauseEnqueue::VisitOMPExclusiveClause(const OMPExclusiveClause *C) { 2494 VisitOMPClauseList(C); 2495} 2496void OMPClauseEnqueue::VisitOMPAllocateClause(const OMPAllocateClause *C) { 2497 VisitOMPClauseList(C); 2498 Visitor->AddStmt(C->getAllocator()); 2499} 2500void OMPClauseEnqueue::VisitOMPPrivateClause(const OMPPrivateClause *C) { 2501 VisitOMPClauseList(C); 2502 for (const auto *E : C->private_copies()) { 2503 Visitor->AddStmt(E); 2504 } 2505} 2506void OMPClauseEnqueue::VisitOMPFirstprivateClause( 2507 const OMPFirstprivateClause *C) { 2508 VisitOMPClauseList(C); 2509 VisitOMPClauseWithPreInit(C); 2510 for (const auto *E : C->private_copies()) { 2511 Visitor->AddStmt(E); 2512 } 2513 for (const auto *E : C->inits()) { 2514 Visitor->AddStmt(E); 2515 } 2516} 2517void OMPClauseEnqueue::VisitOMPLastprivateClause( 2518 const OMPLastprivateClause *C) { 2519 VisitOMPClauseList(C); 2520 VisitOMPClauseWithPostUpdate(C); 2521 for (auto *E : C->private_copies()) { 2522 Visitor->AddStmt(E); 2523 } 2524 for (auto *E : C->source_exprs()) { 2525 Visitor->AddStmt(E); 2526 } 2527 for (auto *E : C->destination_exprs()) { 2528 Visitor->AddStmt(E); 2529 } 2530 for (auto *E : C->assignment_ops()) { 2531 Visitor->AddStmt(E); 2532 } 2533} 2534void OMPClauseEnqueue::VisitOMPSharedClause(const OMPSharedClause *C) { 2535 VisitOMPClauseList(C); 2536} 2537void OMPClauseEnqueue::VisitOMPReductionClause(const OMPReductionClause *C) { 2538 VisitOMPClauseList(C); 2539 VisitOMPClauseWithPostUpdate(C); 2540 for (auto *E : C->privates()) { 2541 Visitor->AddStmt(E); 2542 } 2543 for (auto *E : C->lhs_exprs()) { 2544 Visitor->AddStmt(E); 2545 } 2546 for (auto *E : C->rhs_exprs()) { 2547 Visitor->AddStmt(E); 2548 } 2549 for (auto *E : C->reduction_ops()) { 2550 Visitor->AddStmt(E); 2551 } 2552 if (C->getModifier() == clang::OMPC_REDUCTION_inscan) { 2553 for (auto *E : C->copy_ops()) { 2554 Visitor->AddStmt(E); 2555 } 2556 for (auto *E : C->copy_array_temps()) { 2557 Visitor->AddStmt(E); 2558 } 2559 for (auto *E : C->copy_array_elems()) { 2560 Visitor->AddStmt(E); 2561 } 2562 } 2563} 2564void OMPClauseEnqueue::VisitOMPTaskReductionClause( 2565 const OMPTaskReductionClause *C) { 2566 VisitOMPClauseList(C); 2567 VisitOMPClauseWithPostUpdate(C); 2568 for (auto *E : C->privates()) { 2569 Visitor->AddStmt(E); 2570 } 2571 for (auto *E : C->lhs_exprs()) { 2572 Visitor->AddStmt(E); 2573 } 2574 for (auto *E : C->rhs_exprs()) { 2575 Visitor->AddStmt(E); 2576 } 2577 for (auto *E : C->reduction_ops()) { 2578 Visitor->AddStmt(E); 2579 } 2580} 2581void OMPClauseEnqueue::VisitOMPInReductionClause( 2582 const OMPInReductionClause *C) { 2583 VisitOMPClauseList(C); 2584 VisitOMPClauseWithPostUpdate(C); 2585 for (auto *E : C->privates()) { 2586 Visitor->AddStmt(E); 2587 } 2588 for (auto *E : C->lhs_exprs()) { 2589 Visitor->AddStmt(E); 2590 } 2591 for (auto *E : C->rhs_exprs()) { 2592 Visitor->AddStmt(E); 2593 } 2594 for (auto *E : C->reduction_ops()) { 2595 Visitor->AddStmt(E); 2596 } 2597 for (auto *E : C->taskgroup_descriptors()) 2598 Visitor->AddStmt(E); 2599} 2600void OMPClauseEnqueue::VisitOMPLinearClause(const OMPLinearClause *C) { 2601 VisitOMPClauseList(C); 2602 VisitOMPClauseWithPostUpdate(C); 2603 for (const auto *E : C->privates()) { 2604 Visitor->AddStmt(E); 2605 } 2606 for (const auto *E : C->inits()) { 2607 Visitor->AddStmt(E); 2608 } 2609 for (const auto *E : C->updates()) { 2610 Visitor->AddStmt(E); 2611 } 2612 for (const auto *E : C->finals()) { 2613 Visitor->AddStmt(E); 2614 } 2615 Visitor->AddStmt(C->getStep()); 2616 Visitor->AddStmt(C->getCalcStep()); 2617} 2618void OMPClauseEnqueue::VisitOMPAlignedClause(const OMPAlignedClause *C) { 2619 VisitOMPClauseList(C); 2620 Visitor->AddStmt(C->getAlignment()); 2621} 2622void OMPClauseEnqueue::VisitOMPCopyinClause(const OMPCopyinClause *C) { 2623 VisitOMPClauseList(C); 2624 for (auto *E : C->source_exprs()) { 2625 Visitor->AddStmt(E); 2626 } 2627 for (auto *E : C->destination_exprs()) { 2628 Visitor->AddStmt(E); 2629 } 2630 for (auto *E : C->assignment_ops()) { 2631 Visitor->AddStmt(E); 2632 } 2633} 2634void OMPClauseEnqueue::VisitOMPCopyprivateClause( 2635 const OMPCopyprivateClause *C) { 2636 VisitOMPClauseList(C); 2637 for (auto *E : C->source_exprs()) { 2638 Visitor->AddStmt(E); 2639 } 2640 for (auto *E : C->destination_exprs()) { 2641 Visitor->AddStmt(E); 2642 } 2643 for (auto *E : C->assignment_ops()) { 2644 Visitor->AddStmt(E); 2645 } 2646} 2647void OMPClauseEnqueue::VisitOMPFlushClause(const OMPFlushClause *C) { 2648 VisitOMPClauseList(C); 2649} 2650void OMPClauseEnqueue::VisitOMPDepobjClause(const OMPDepobjClause *C) { 2651 Visitor->AddStmt(C->getDepobj()); 2652} 2653void OMPClauseEnqueue::VisitOMPDependClause(const OMPDependClause *C) { 2654 VisitOMPClauseList(C); 2655} 2656void OMPClauseEnqueue::VisitOMPMapClause(const OMPMapClause *C) { 2657 VisitOMPClauseList(C); 2658} 2659void OMPClauseEnqueue::VisitOMPDistScheduleClause( 2660 const OMPDistScheduleClause *C) { 2661 VisitOMPClauseWithPreInit(C); 2662 Visitor->AddStmt(C->getChunkSize()); 2663} 2664void OMPClauseEnqueue::VisitOMPDefaultmapClause( 2665 const OMPDefaultmapClause * /*C*/) {} 2666void OMPClauseEnqueue::VisitOMPToClause(const OMPToClause *C) { 2667 VisitOMPClauseList(C); 2668} 2669void OMPClauseEnqueue::VisitOMPFromClause(const OMPFromClause *C) { 2670 VisitOMPClauseList(C); 2671} 2672void OMPClauseEnqueue::VisitOMPUseDevicePtrClause( 2673 const OMPUseDevicePtrClause *C) { 2674 VisitOMPClauseList(C); 2675} 2676void OMPClauseEnqueue::VisitOMPUseDeviceAddrClause( 2677 const OMPUseDeviceAddrClause *C) { 2678 VisitOMPClauseList(C); 2679} 2680void OMPClauseEnqueue::VisitOMPIsDevicePtrClause( 2681 const OMPIsDevicePtrClause *C) { 2682 VisitOMPClauseList(C); 2683} 2684void OMPClauseEnqueue::VisitOMPHasDeviceAddrClause( 2685 const OMPHasDeviceAddrClause *C) { 2686 VisitOMPClauseList(C); 2687} 2688void OMPClauseEnqueue::VisitOMPNontemporalClause( 2689 const OMPNontemporalClause *C) { 2690 VisitOMPClauseList(C); 2691 for (const auto *E : C->private_refs()) 2692 Visitor->AddStmt(E); 2693} 2694void OMPClauseEnqueue::VisitOMPOrderClause(const OMPOrderClause *C) {} 2695void OMPClauseEnqueue::VisitOMPUsesAllocatorsClause( 2696 const OMPUsesAllocatorsClause *C) { 2697 for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) { 2698 const OMPUsesAllocatorsClause::Data &D = C->getAllocatorData(I); 2699 Visitor->AddStmt(D.Allocator); 2700 Visitor->AddStmt(D.AllocatorTraits); 2701 } 2702} 2703void OMPClauseEnqueue::VisitOMPAffinityClause(const OMPAffinityClause *C) { 2704 Visitor->AddStmt(C->getModifier()); 2705 for (const Expr *E : C->varlists()) 2706 Visitor->AddStmt(E); 2707} 2708void OMPClauseEnqueue::VisitOMPBindClause(const OMPBindClause *C) {} 2709void OMPClauseEnqueue::VisitOMPXDynCGroupMemClause( 2710 const OMPXDynCGroupMemClause *C) { 2711 VisitOMPClauseWithPreInit(C); 2712 Visitor->AddStmt(C->getSize()); 2713} 2714 2715} // namespace 2716 2717void EnqueueVisitor::EnqueueChildren(const OMPClause *S) { 2718 unsigned size = WL.size(); 2719 OMPClauseEnqueue Visitor(this); 2720 Visitor.Visit(S); 2721 if (size == WL.size()) 2722 return; 2723 // Now reverse the entries we just added. This will match the DFS 2724 // ordering performed by the worklist. 2725 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 2726 std::reverse(I, E); 2727} 2728void EnqueueVisitor::VisitAddrLabelExpr(const AddrLabelExpr *E) { 2729 WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent)); 2730} 2731void EnqueueVisitor::VisitBlockExpr(const BlockExpr *B) { 2732 AddDecl(B->getBlockDecl()); 2733} 2734void EnqueueVisitor::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) { 2735 EnqueueChildren(E); 2736 AddTypeLoc(E->getTypeSourceInfo()); 2737} 2738void EnqueueVisitor::VisitCompoundStmt(const CompoundStmt *S) { 2739 for (auto &I : llvm::reverse(S->body())) 2740 AddStmt(I); 2741} 2742void EnqueueVisitor::VisitMSDependentExistsStmt( 2743 const MSDependentExistsStmt *S) { 2744 AddStmt(S->getSubStmt()); 2745 AddDeclarationNameInfo(S); 2746 if (NestedNameSpecifierLoc QualifierLoc = S->getQualifierLoc()) 2747 AddNestedNameSpecifierLoc(QualifierLoc); 2748} 2749 2750void EnqueueVisitor::VisitCXXDependentScopeMemberExpr( 2751 const CXXDependentScopeMemberExpr *E) { 2752 if (E->hasExplicitTemplateArgs()) 2753 AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs()); 2754 AddDeclarationNameInfo(E); 2755 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 2756 AddNestedNameSpecifierLoc(QualifierLoc); 2757 if (!E->isImplicitAccess()) 2758 AddStmt(E->getBase()); 2759} 2760void EnqueueVisitor::VisitCXXNewExpr(const CXXNewExpr *E) { 2761 // Enqueue the initializer , if any. 2762 AddStmt(E->getInitializer()); 2763 // Enqueue the array size, if any. 2764 AddStmt(E->getArraySize().value_or(nullptr)); 2765 // Enqueue the allocated type. 2766 AddTypeLoc(E->getAllocatedTypeSourceInfo()); 2767 // Enqueue the placement arguments. 2768 for (unsigned I = E->getNumPlacementArgs(); I > 0; --I) 2769 AddStmt(E->getPlacementArg(I - 1)); 2770} 2771void EnqueueVisitor::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *CE) { 2772 for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I) 2773 AddStmt(CE->getArg(I - 1)); 2774 AddStmt(CE->getCallee()); 2775 AddStmt(CE->getArg(0)); 2776} 2777void EnqueueVisitor::VisitCXXPseudoDestructorExpr( 2778 const CXXPseudoDestructorExpr *E) { 2779 // Visit the name of the type being destroyed. 2780 AddTypeLoc(E->getDestroyedTypeInfo()); 2781 // Visit the scope type that looks disturbingly like the nested-name-specifier 2782 // but isn't. 2783 AddTypeLoc(E->getScopeTypeInfo()); 2784 // Visit the nested-name-specifier. 2785 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 2786 AddNestedNameSpecifierLoc(QualifierLoc); 2787 // Visit base expression. 2788 AddStmt(E->getBase()); 2789} 2790void EnqueueVisitor::VisitCXXScalarValueInitExpr( 2791 const CXXScalarValueInitExpr *E) { 2792 AddTypeLoc(E->getTypeSourceInfo()); 2793} 2794void EnqueueVisitor::VisitCXXTemporaryObjectExpr( 2795 const CXXTemporaryObjectExpr *E) { 2796 EnqueueChildren(E); 2797 AddTypeLoc(E->getTypeSourceInfo()); 2798} 2799void EnqueueVisitor::VisitCXXTypeidExpr(const CXXTypeidExpr *E) { 2800 EnqueueChildren(E); 2801 if (E->isTypeOperand()) 2802 AddTypeLoc(E->getTypeOperandSourceInfo()); 2803} 2804 2805void EnqueueVisitor::VisitCXXUnresolvedConstructExpr( 2806 const CXXUnresolvedConstructExpr *E) { 2807 EnqueueChildren(E); 2808 AddTypeLoc(E->getTypeSourceInfo()); 2809} 2810void EnqueueVisitor::VisitCXXUuidofExpr(const CXXUuidofExpr *E) { 2811 EnqueueChildren(E); 2812 if (E->isTypeOperand()) 2813 AddTypeLoc(E->getTypeOperandSourceInfo()); 2814} 2815 2816void EnqueueVisitor::VisitCXXCatchStmt(const CXXCatchStmt *S) { 2817 EnqueueChildren(S); 2818 AddDecl(S->getExceptionDecl()); 2819} 2820 2821void EnqueueVisitor::VisitCXXForRangeStmt(const CXXForRangeStmt *S) { 2822 AddStmt(S->getBody()); 2823 AddStmt(S->getRangeInit()); 2824 AddDecl(S->getLoopVariable()); 2825} 2826 2827void EnqueueVisitor::VisitDeclRefExpr(const DeclRefExpr *DR) { 2828 if (DR->hasExplicitTemplateArgs()) 2829 AddExplicitTemplateArgs(DR->getTemplateArgs(), DR->getNumTemplateArgs()); 2830 WL.push_back(DeclRefExprParts(DR, Parent)); 2831} 2832void EnqueueVisitor::VisitDependentScopeDeclRefExpr( 2833 const DependentScopeDeclRefExpr *E) { 2834 if (E->hasExplicitTemplateArgs()) 2835 AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs()); 2836 AddDeclarationNameInfo(E); 2837 AddNestedNameSpecifierLoc(E->getQualifierLoc()); 2838} 2839void EnqueueVisitor::VisitDeclStmt(const DeclStmt *S) { 2840 unsigned size = WL.size(); 2841 bool isFirst = true; 2842 for (const auto *D : S->decls()) { 2843 AddDecl(D, isFirst); 2844 isFirst = false; 2845 } 2846 if (size == WL.size()) 2847 return; 2848 // Now reverse the entries we just added. This will match the DFS 2849 // ordering performed by the worklist. 2850 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 2851 std::reverse(I, E); 2852} 2853void EnqueueVisitor::VisitDesignatedInitExpr(const DesignatedInitExpr *E) { 2854 AddStmt(E->getInit()); 2855 for (const DesignatedInitExpr::Designator &D : 2856 llvm::reverse(E->designators())) { 2857 if (D.isFieldDesignator()) { 2858 if (FieldDecl *Field = D.getField()) 2859 AddMemberRef(Field, D.getFieldLoc()); 2860 continue; 2861 } 2862 if (D.isArrayDesignator()) { 2863 AddStmt(E->getArrayIndex(D)); 2864 continue; 2865 } 2866 assert(D.isArrayRangeDesignator() && "Unknown designator kind"); 2867 AddStmt(E->getArrayRangeEnd(D)); 2868 AddStmt(E->getArrayRangeStart(D)); 2869 } 2870} 2871void EnqueueVisitor::VisitExplicitCastExpr(const ExplicitCastExpr *E) { 2872 EnqueueChildren(E); 2873 AddTypeLoc(E->getTypeInfoAsWritten()); 2874} 2875void EnqueueVisitor::VisitForStmt(const ForStmt *FS) { 2876 AddStmt(FS->getBody()); 2877 AddStmt(FS->getInc()); 2878 AddStmt(FS->getCond()); 2879 AddDecl(FS->getConditionVariable()); 2880 AddStmt(FS->getInit()); 2881} 2882void EnqueueVisitor::VisitGotoStmt(const GotoStmt *GS) { 2883 WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent)); 2884} 2885void EnqueueVisitor::VisitIfStmt(const IfStmt *If) { 2886 AddStmt(If->getElse()); 2887 AddStmt(If->getThen()); 2888 AddStmt(If->getCond()); 2889 AddStmt(If->getInit()); 2890 AddDecl(If->getConditionVariable()); 2891} 2892void EnqueueVisitor::VisitInitListExpr(const InitListExpr *IE) { 2893 // We care about the syntactic form of the initializer list, only. 2894 if (InitListExpr *Syntactic = IE->getSyntacticForm()) 2895 IE = Syntactic; 2896 EnqueueChildren(IE); 2897} 2898void EnqueueVisitor::VisitMemberExpr(const MemberExpr *M) { 2899 WL.push_back(MemberExprParts(M, Parent)); 2900 2901 // If the base of the member access expression is an implicit 'this', don't 2902 // visit it. 2903 // FIXME: If we ever want to show these implicit accesses, this will be 2904 // unfortunate. However, clang_getCursor() relies on this behavior. 2905 if (M->isImplicitAccess()) 2906 return; 2907 2908 // Ignore base anonymous struct/union fields, otherwise they will shadow the 2909 // real field that we are interested in. 2910 if (auto *SubME = dyn_cast<MemberExpr>(M->getBase())) { 2911 if (auto *FD = dyn_cast_or_null<FieldDecl>(SubME->getMemberDecl())) { 2912 if (FD->isAnonymousStructOrUnion()) { 2913 AddStmt(SubME->getBase()); 2914 return; 2915 } 2916 } 2917 } 2918 2919 AddStmt(M->getBase()); 2920} 2921void EnqueueVisitor::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { 2922 AddTypeLoc(E->getEncodedTypeSourceInfo()); 2923} 2924void EnqueueVisitor::VisitObjCMessageExpr(const ObjCMessageExpr *M) { 2925 EnqueueChildren(M); 2926 AddTypeLoc(M->getClassReceiverTypeInfo()); 2927} 2928void EnqueueVisitor::VisitOffsetOfExpr(const OffsetOfExpr *E) { 2929 // Visit the components of the offsetof expression. 2930 for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) { 2931 const OffsetOfNode &Node = E->getComponent(I - 1); 2932 switch (Node.getKind()) { 2933 case OffsetOfNode::Array: 2934 AddStmt(E->getIndexExpr(Node.getArrayExprIndex())); 2935 break; 2936 case OffsetOfNode::Field: 2937 AddMemberRef(Node.getField(), Node.getSourceRange().getEnd()); 2938 break; 2939 case OffsetOfNode::Identifier: 2940 case OffsetOfNode::Base: 2941 continue; 2942 } 2943 } 2944 // Visit the type into which we're computing the offset. 2945 AddTypeLoc(E->getTypeSourceInfo()); 2946} 2947void EnqueueVisitor::VisitOverloadExpr(const OverloadExpr *E) { 2948 if (E->hasExplicitTemplateArgs()) 2949 AddExplicitTemplateArgs(E->getTemplateArgs(), E->getNumTemplateArgs()); 2950 WL.push_back(OverloadExprParts(E, Parent)); 2951} 2952void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr( 2953 const UnaryExprOrTypeTraitExpr *E) { 2954 EnqueueChildren(E); 2955 if (E->isArgumentType()) 2956 AddTypeLoc(E->getArgumentTypeInfo()); 2957} 2958void EnqueueVisitor::VisitStmt(const Stmt *S) { EnqueueChildren(S); } 2959void EnqueueVisitor::VisitSwitchStmt(const SwitchStmt *S) { 2960 AddStmt(S->getBody()); 2961 AddStmt(S->getCond()); 2962 AddDecl(S->getConditionVariable()); 2963} 2964 2965void EnqueueVisitor::VisitWhileStmt(const WhileStmt *W) { 2966 AddStmt(W->getBody()); 2967 AddStmt(W->getCond()); 2968 AddDecl(W->getConditionVariable()); 2969} 2970 2971void EnqueueVisitor::VisitTypeTraitExpr(const TypeTraitExpr *E) { 2972 for (unsigned I = E->getNumArgs(); I > 0; --I) 2973 AddTypeLoc(E->getArg(I - 1)); 2974} 2975 2976void EnqueueVisitor::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) { 2977 AddTypeLoc(E->getQueriedTypeSourceInfo()); 2978} 2979 2980void EnqueueVisitor::VisitExpressionTraitExpr(const ExpressionTraitExpr *E) { 2981 EnqueueChildren(E); 2982} 2983 2984void EnqueueVisitor::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U) { 2985 VisitOverloadExpr(U); 2986 if (!U->isImplicitAccess()) 2987 AddStmt(U->getBase()); 2988} 2989void EnqueueVisitor::VisitVAArgExpr(const VAArgExpr *E) { 2990 AddStmt(E->getSubExpr()); 2991 AddTypeLoc(E->getWrittenTypeInfo()); 2992} 2993void EnqueueVisitor::VisitSizeOfPackExpr(const SizeOfPackExpr *E) { 2994 WL.push_back(SizeOfPackExprParts(E, Parent)); 2995} 2996void EnqueueVisitor::VisitOpaqueValueExpr(const OpaqueValueExpr *E) { 2997 // If the opaque value has a source expression, just transparently 2998 // visit that. This is useful for (e.g.) pseudo-object expressions. 2999 if (Expr *SourceExpr = E->getSourceExpr()) 3000 return Visit(SourceExpr); 3001} 3002void EnqueueVisitor::VisitLambdaExpr(const LambdaExpr *E) { 3003 AddStmt(E->getBody()); 3004 WL.push_back(LambdaExprParts(E, Parent)); 3005} 3006void EnqueueVisitor::VisitConceptSpecializationExpr( 3007 const ConceptSpecializationExpr *E) { 3008 WL.push_back(ConceptSpecializationExprVisit(E, Parent)); 3009} 3010void EnqueueVisitor::VisitRequiresExpr(const RequiresExpr *E) { 3011 WL.push_back(RequiresExprVisit(E, Parent)); 3012 for (ParmVarDecl *VD : E->getLocalParameters()) 3013 AddDecl(VD); 3014} 3015void EnqueueVisitor::VisitCXXParenListInitExpr(const CXXParenListInitExpr *E) { 3016 EnqueueChildren(E); 3017} 3018void EnqueueVisitor::VisitPseudoObjectExpr(const PseudoObjectExpr *E) { 3019 // Treat the expression like its syntactic form. 3020 Visit(E->getSyntacticForm()); 3021} 3022 3023void EnqueueVisitor::VisitOMPExecutableDirective( 3024 const OMPExecutableDirective *D) { 3025 EnqueueChildren(D); 3026 for (ArrayRef<OMPClause *>::iterator I = D->clauses().begin(), 3027 E = D->clauses().end(); 3028 I != E; ++I) 3029 EnqueueChildren(*I); 3030} 3031 3032void EnqueueVisitor::VisitOMPLoopBasedDirective( 3033 const OMPLoopBasedDirective *D) { 3034 VisitOMPExecutableDirective(D); 3035} 3036 3037void EnqueueVisitor::VisitOMPLoopDirective(const OMPLoopDirective *D) { 3038 VisitOMPLoopBasedDirective(D); 3039} 3040 3041void EnqueueVisitor::VisitOMPParallelDirective(const OMPParallelDirective *D) { 3042 VisitOMPExecutableDirective(D); 3043} 3044 3045void EnqueueVisitor::VisitOMPSimdDirective(const OMPSimdDirective *D) { 3046 VisitOMPLoopDirective(D); 3047} 3048 3049void EnqueueVisitor::VisitOMPLoopTransformationDirective( 3050 const OMPLoopTransformationDirective *D) { 3051 VisitOMPLoopBasedDirective(D); 3052} 3053 3054void EnqueueVisitor::VisitOMPTileDirective(const OMPTileDirective *D) { 3055 VisitOMPLoopTransformationDirective(D); 3056} 3057 3058void EnqueueVisitor::VisitOMPUnrollDirective(const OMPUnrollDirective *D) { 3059 VisitOMPLoopTransformationDirective(D); 3060} 3061 3062void EnqueueVisitor::VisitOMPForDirective(const OMPForDirective *D) { 3063 VisitOMPLoopDirective(D); 3064} 3065 3066void EnqueueVisitor::VisitOMPForSimdDirective(const OMPForSimdDirective *D) { 3067 VisitOMPLoopDirective(D); 3068} 3069 3070void EnqueueVisitor::VisitOMPSectionsDirective(const OMPSectionsDirective *D) { 3071 VisitOMPExecutableDirective(D); 3072} 3073 3074void EnqueueVisitor::VisitOMPSectionDirective(const OMPSectionDirective *D) { 3075 VisitOMPExecutableDirective(D); 3076} 3077 3078void EnqueueVisitor::VisitOMPSingleDirective(const OMPSingleDirective *D) { 3079 VisitOMPExecutableDirective(D); 3080} 3081 3082void EnqueueVisitor::VisitOMPMasterDirective(const OMPMasterDirective *D) { 3083 VisitOMPExecutableDirective(D); 3084} 3085 3086void EnqueueVisitor::VisitOMPCriticalDirective(const OMPCriticalDirective *D) { 3087 VisitOMPExecutableDirective(D); 3088 AddDeclarationNameInfo(D); 3089} 3090 3091void EnqueueVisitor::VisitOMPParallelForDirective( 3092 const OMPParallelForDirective *D) { 3093 VisitOMPLoopDirective(D); 3094} 3095 3096void EnqueueVisitor::VisitOMPParallelForSimdDirective( 3097 const OMPParallelForSimdDirective *D) { 3098 VisitOMPLoopDirective(D); 3099} 3100 3101void EnqueueVisitor::VisitOMPParallelMasterDirective( 3102 const OMPParallelMasterDirective *D) { 3103 VisitOMPExecutableDirective(D); 3104} 3105 3106void EnqueueVisitor::VisitOMPParallelMaskedDirective( 3107 const OMPParallelMaskedDirective *D) { 3108 VisitOMPExecutableDirective(D); 3109} 3110 3111void EnqueueVisitor::VisitOMPParallelSectionsDirective( 3112 const OMPParallelSectionsDirective *D) { 3113 VisitOMPExecutableDirective(D); 3114} 3115 3116void EnqueueVisitor::VisitOMPTaskDirective(const OMPTaskDirective *D) { 3117 VisitOMPExecutableDirective(D); 3118} 3119 3120void EnqueueVisitor::VisitOMPTaskyieldDirective( 3121 const OMPTaskyieldDirective *D) { 3122 VisitOMPExecutableDirective(D); 3123} 3124 3125void EnqueueVisitor::VisitOMPBarrierDirective(const OMPBarrierDirective *D) { 3126 VisitOMPExecutableDirective(D); 3127} 3128 3129void EnqueueVisitor::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D) { 3130 VisitOMPExecutableDirective(D); 3131} 3132 3133void EnqueueVisitor::VisitOMPErrorDirective(const OMPErrorDirective *D) { 3134 VisitOMPExecutableDirective(D); 3135} 3136 3137void EnqueueVisitor::VisitOMPTaskgroupDirective( 3138 const OMPTaskgroupDirective *D) { 3139 VisitOMPExecutableDirective(D); 3140 if (const Expr *E = D->getReductionRef()) 3141 VisitStmt(E); 3142} 3143 3144void EnqueueVisitor::VisitOMPFlushDirective(const OMPFlushDirective *D) { 3145 VisitOMPExecutableDirective(D); 3146} 3147 3148void EnqueueVisitor::VisitOMPDepobjDirective(const OMPDepobjDirective *D) { 3149 VisitOMPExecutableDirective(D); 3150} 3151 3152void EnqueueVisitor::VisitOMPScanDirective(const OMPScanDirective *D) { 3153 VisitOMPExecutableDirective(D); 3154} 3155 3156void EnqueueVisitor::VisitOMPOrderedDirective(const OMPOrderedDirective *D) { 3157 VisitOMPExecutableDirective(D); 3158} 3159 3160void EnqueueVisitor::VisitOMPAtomicDirective(const OMPAtomicDirective *D) { 3161 VisitOMPExecutableDirective(D); 3162} 3163 3164void EnqueueVisitor::VisitOMPTargetDirective(const OMPTargetDirective *D) { 3165 VisitOMPExecutableDirective(D); 3166} 3167 3168void EnqueueVisitor::VisitOMPTargetDataDirective( 3169 const OMPTargetDataDirective *D) { 3170 VisitOMPExecutableDirective(D); 3171} 3172 3173void EnqueueVisitor::VisitOMPTargetEnterDataDirective( 3174 const OMPTargetEnterDataDirective *D) { 3175 VisitOMPExecutableDirective(D); 3176} 3177 3178void EnqueueVisitor::VisitOMPTargetExitDataDirective( 3179 const OMPTargetExitDataDirective *D) { 3180 VisitOMPExecutableDirective(D); 3181} 3182 3183void EnqueueVisitor::VisitOMPTargetParallelDirective( 3184 const OMPTargetParallelDirective *D) { 3185 VisitOMPExecutableDirective(D); 3186} 3187 3188void EnqueueVisitor::VisitOMPTargetParallelForDirective( 3189 const OMPTargetParallelForDirective *D) { 3190 VisitOMPLoopDirective(D); 3191} 3192 3193void EnqueueVisitor::VisitOMPTeamsDirective(const OMPTeamsDirective *D) { 3194 VisitOMPExecutableDirective(D); 3195} 3196 3197void EnqueueVisitor::VisitOMPCancellationPointDirective( 3198 const OMPCancellationPointDirective *D) { 3199 VisitOMPExecutableDirective(D); 3200} 3201 3202void EnqueueVisitor::VisitOMPCancelDirective(const OMPCancelDirective *D) { 3203 VisitOMPExecutableDirective(D); 3204} 3205 3206void EnqueueVisitor::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D) { 3207 VisitOMPLoopDirective(D); 3208} 3209 3210void EnqueueVisitor::VisitOMPTaskLoopSimdDirective( 3211 const OMPTaskLoopSimdDirective *D) { 3212 VisitOMPLoopDirective(D); 3213} 3214 3215void EnqueueVisitor::VisitOMPMasterTaskLoopDirective( 3216 const OMPMasterTaskLoopDirective *D) { 3217 VisitOMPLoopDirective(D); 3218} 3219 3220void EnqueueVisitor::VisitOMPMaskedTaskLoopDirective( 3221 const OMPMaskedTaskLoopDirective *D) { 3222 VisitOMPLoopDirective(D); 3223} 3224 3225void EnqueueVisitor::VisitOMPMasterTaskLoopSimdDirective( 3226 const OMPMasterTaskLoopSimdDirective *D) { 3227 VisitOMPLoopDirective(D); 3228} 3229 3230void EnqueueVisitor::VisitOMPMaskedTaskLoopSimdDirective( 3231 const OMPMaskedTaskLoopSimdDirective *D) { 3232 VisitOMPLoopDirective(D); 3233} 3234 3235void EnqueueVisitor::VisitOMPParallelMasterTaskLoopDirective( 3236 const OMPParallelMasterTaskLoopDirective *D) { 3237 VisitOMPLoopDirective(D); 3238} 3239 3240void EnqueueVisitor::VisitOMPParallelMaskedTaskLoopDirective( 3241 const OMPParallelMaskedTaskLoopDirective *D) { 3242 VisitOMPLoopDirective(D); 3243} 3244 3245void EnqueueVisitor::VisitOMPParallelMasterTaskLoopSimdDirective( 3246 const OMPParallelMasterTaskLoopSimdDirective *D) { 3247 VisitOMPLoopDirective(D); 3248} 3249 3250void EnqueueVisitor::VisitOMPParallelMaskedTaskLoopSimdDirective( 3251 const OMPParallelMaskedTaskLoopSimdDirective *D) { 3252 VisitOMPLoopDirective(D); 3253} 3254 3255void EnqueueVisitor::VisitOMPDistributeDirective( 3256 const OMPDistributeDirective *D) { 3257 VisitOMPLoopDirective(D); 3258} 3259 3260void EnqueueVisitor::VisitOMPDistributeParallelForDirective( 3261 const OMPDistributeParallelForDirective *D) { 3262 VisitOMPLoopDirective(D); 3263} 3264 3265void EnqueueVisitor::VisitOMPDistributeParallelForSimdDirective( 3266 const OMPDistributeParallelForSimdDirective *D) { 3267 VisitOMPLoopDirective(D); 3268} 3269 3270void EnqueueVisitor::VisitOMPDistributeSimdDirective( 3271 const OMPDistributeSimdDirective *D) { 3272 VisitOMPLoopDirective(D); 3273} 3274 3275void EnqueueVisitor::VisitOMPTargetParallelForSimdDirective( 3276 const OMPTargetParallelForSimdDirective *D) { 3277 VisitOMPLoopDirective(D); 3278} 3279 3280void EnqueueVisitor::VisitOMPTargetSimdDirective( 3281 const OMPTargetSimdDirective *D) { 3282 VisitOMPLoopDirective(D); 3283} 3284 3285void EnqueueVisitor::VisitOMPTeamsDistributeDirective( 3286 const OMPTeamsDistributeDirective *D) { 3287 VisitOMPLoopDirective(D); 3288} 3289 3290void EnqueueVisitor::VisitOMPTeamsDistributeSimdDirective( 3291 const OMPTeamsDistributeSimdDirective *D) { 3292 VisitOMPLoopDirective(D); 3293} 3294 3295void EnqueueVisitor::VisitOMPTeamsDistributeParallelForSimdDirective( 3296 const OMPTeamsDistributeParallelForSimdDirective *D) { 3297 VisitOMPLoopDirective(D); 3298} 3299 3300void EnqueueVisitor::VisitOMPTeamsDistributeParallelForDirective( 3301 const OMPTeamsDistributeParallelForDirective *D) { 3302 VisitOMPLoopDirective(D); 3303} 3304 3305void EnqueueVisitor::VisitOMPTargetTeamsDirective( 3306 const OMPTargetTeamsDirective *D) { 3307 VisitOMPExecutableDirective(D); 3308} 3309 3310void EnqueueVisitor::VisitOMPTargetTeamsDistributeDirective( 3311 const OMPTargetTeamsDistributeDirective *D) { 3312 VisitOMPLoopDirective(D); 3313} 3314 3315void EnqueueVisitor::VisitOMPTargetTeamsDistributeParallelForDirective( 3316 const OMPTargetTeamsDistributeParallelForDirective *D) { 3317 VisitOMPLoopDirective(D); 3318} 3319 3320void EnqueueVisitor::VisitOMPTargetTeamsDistributeParallelForSimdDirective( 3321 const OMPTargetTeamsDistributeParallelForSimdDirective *D) { 3322 VisitOMPLoopDirective(D); 3323} 3324 3325void EnqueueVisitor::VisitOMPTargetTeamsDistributeSimdDirective( 3326 const OMPTargetTeamsDistributeSimdDirective *D) { 3327 VisitOMPLoopDirective(D); 3328} 3329 3330void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) { 3331 EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU, RegionOfInterest)) 3332 .Visit(S); 3333} 3334 3335bool CursorVisitor::IsInRegionOfInterest(CXCursor C) { 3336 if (RegionOfInterest.isValid()) { 3337 SourceRange Range = getRawCursorExtent(C); 3338 if (Range.isInvalid() || CompareRegionOfInterest(Range)) 3339 return false; 3340 } 3341 return true; 3342} 3343 3344bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) { 3345 while (!WL.empty()) { 3346 // Dequeue the worklist item. 3347 VisitorJob LI = WL.pop_back_val(); 3348 3349 // Set the Parent field, then back to its old value once we're done. 3350 SetParentRAII SetParent(Parent, StmtParent, LI.getParent()); 3351 3352 switch (LI.getKind()) { 3353 case VisitorJob::DeclVisitKind: { 3354 const Decl *D = cast<DeclVisit>(&LI)->get(); 3355 if (!D) 3356 continue; 3357 3358 // For now, perform default visitation for Decls. 3359 if (Visit(MakeCXCursor(D, TU, RegionOfInterest, 3360 cast<DeclVisit>(&LI)->isFirst()))) 3361 return true; 3362 3363 continue; 3364 } 3365 case VisitorJob::ExplicitTemplateArgsVisitKind: { 3366 for (const TemplateArgumentLoc &Arg : 3367 *cast<ExplicitTemplateArgsVisit>(&LI)) { 3368 if (VisitTemplateArgumentLoc(Arg)) 3369 return true; 3370 } 3371 continue; 3372 } 3373 case VisitorJob::TypeLocVisitKind: { 3374 // Perform default visitation for TypeLocs. 3375 if (Visit(cast<TypeLocVisit>(&LI)->get())) 3376 return true; 3377 continue; 3378 } 3379 case VisitorJob::LabelRefVisitKind: { 3380 const LabelDecl *LS = cast<LabelRefVisit>(&LI)->get(); 3381 if (LabelStmt *stmt = LS->getStmt()) { 3382 if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(), 3383 TU))) { 3384 return true; 3385 } 3386 } 3387 continue; 3388 } 3389 3390 case VisitorJob::NestedNameSpecifierLocVisitKind: { 3391 NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI); 3392 if (VisitNestedNameSpecifierLoc(V->get())) 3393 return true; 3394 continue; 3395 } 3396 3397 case VisitorJob::DeclarationNameInfoVisitKind: { 3398 if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI)->get())) 3399 return true; 3400 continue; 3401 } 3402 case VisitorJob::MemberRefVisitKind: { 3403 MemberRefVisit *V = cast<MemberRefVisit>(&LI); 3404 if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU))) 3405 return true; 3406 continue; 3407 } 3408 case VisitorJob::StmtVisitKind: { 3409 const Stmt *S = cast<StmtVisit>(&LI)->get(); 3410 if (!S) 3411 continue; 3412 3413 // Update the current cursor. 3414 CXCursor Cursor = MakeCXCursor(S, StmtParent, TU, RegionOfInterest); 3415 if (!IsInRegionOfInterest(Cursor)) 3416 continue; 3417 switch (Visitor(Cursor, Parent, ClientData)) { 3418 case CXChildVisit_Break: 3419 return true; 3420 case CXChildVisit_Continue: 3421 break; 3422 case CXChildVisit_Recurse: 3423 if (PostChildrenVisitor) 3424 WL.push_back(PostChildrenVisit(nullptr, Cursor)); 3425 EnqueueWorkList(WL, S); 3426 break; 3427 } 3428 continue; 3429 } 3430 case VisitorJob::MemberExprPartsKind: { 3431 // Handle the other pieces in the MemberExpr besides the base. 3432 const MemberExpr *M = cast<MemberExprParts>(&LI)->get(); 3433 3434 // Visit the nested-name-specifier 3435 if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc()) 3436 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 3437 return true; 3438 3439 // Visit the declaration name. 3440 if (VisitDeclarationNameInfo(M->getMemberNameInfo())) 3441 return true; 3442 3443 // Visit the explicitly-specified template arguments, if any. 3444 if (M->hasExplicitTemplateArgs()) { 3445 for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(), 3446 *ArgEnd = Arg + M->getNumTemplateArgs(); 3447 Arg != ArgEnd; ++Arg) { 3448 if (VisitTemplateArgumentLoc(*Arg)) 3449 return true; 3450 } 3451 } 3452 continue; 3453 } 3454 case VisitorJob::DeclRefExprPartsKind: { 3455 const DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get(); 3456 // Visit nested-name-specifier, if present. 3457 if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc()) 3458 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 3459 return true; 3460 // Visit declaration name. 3461 if (VisitDeclarationNameInfo(DR->getNameInfo())) 3462 return true; 3463 continue; 3464 } 3465 case VisitorJob::OverloadExprPartsKind: { 3466 const OverloadExpr *O = cast<OverloadExprParts>(&LI)->get(); 3467 // Visit the nested-name-specifier. 3468 if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc()) 3469 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 3470 return true; 3471 // Visit the declaration name. 3472 if (VisitDeclarationNameInfo(O->getNameInfo())) 3473 return true; 3474 // Visit the overloaded declaration reference. 3475 if (Visit(MakeCursorOverloadedDeclRef(O, TU))) 3476 return true; 3477 continue; 3478 } 3479 case VisitorJob::SizeOfPackExprPartsKind: { 3480 const SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get(); 3481 NamedDecl *Pack = E->getPack(); 3482 if (isa<TemplateTypeParmDecl>(Pack)) { 3483 if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack), 3484 E->getPackLoc(), TU))) 3485 return true; 3486 3487 continue; 3488 } 3489 3490 if (isa<TemplateTemplateParmDecl>(Pack)) { 3491 if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack), 3492 E->getPackLoc(), TU))) 3493 return true; 3494 3495 continue; 3496 } 3497 3498 // Non-type template parameter packs and function parameter packs are 3499 // treated like DeclRefExpr cursors. 3500 continue; 3501 } 3502 3503 case VisitorJob::LambdaExprPartsKind: { 3504 // Visit non-init captures. 3505 const LambdaExpr *E = cast<LambdaExprParts>(&LI)->get(); 3506 for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(), 3507 CEnd = E->explicit_capture_end(); 3508 C != CEnd; ++C) { 3509 if (!C->capturesVariable()) 3510 continue; 3511 // TODO: handle structured bindings here ? 3512 if (!isa<VarDecl>(C->getCapturedVar())) 3513 continue; 3514 if (Visit(MakeCursorVariableRef(cast<VarDecl>(C->getCapturedVar()), 3515 C->getLocation(), TU))) 3516 return true; 3517 } 3518 // Visit init captures 3519 for (auto InitExpr : E->capture_inits()) { 3520 if (InitExpr && Visit(InitExpr)) 3521 return true; 3522 } 3523 3524 TypeLoc TL = E->getCallOperator()->getTypeSourceInfo()->getTypeLoc(); 3525 // Visit parameters and return type, if present. 3526 if (FunctionTypeLoc Proto = TL.getAs<FunctionProtoTypeLoc>()) { 3527 if (E->hasExplicitParameters()) { 3528 // Visit parameters. 3529 for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I) 3530 if (Visit(MakeCXCursor(Proto.getParam(I), TU))) 3531 return true; 3532 } 3533 if (E->hasExplicitResultType()) { 3534 // Visit result type. 3535 if (Visit(Proto.getReturnLoc())) 3536 return true; 3537 } 3538 } 3539 break; 3540 } 3541 3542 case VisitorJob::ConceptSpecializationExprVisitKind: { 3543 const ConceptSpecializationExpr *E = 3544 cast<ConceptSpecializationExprVisit>(&LI)->get(); 3545 if (NestedNameSpecifierLoc QualifierLoc = 3546 E->getNestedNameSpecifierLoc()) { 3547 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 3548 return true; 3549 } 3550 3551 if (E->getNamedConcept() && 3552 Visit(MakeCursorTemplateRef(E->getNamedConcept(), 3553 E->getConceptNameLoc(), TU))) 3554 return true; 3555 3556 if (auto Args = E->getTemplateArgsAsWritten()) { 3557 for (const auto &Arg : Args->arguments()) { 3558 if (VisitTemplateArgumentLoc(Arg)) 3559 return true; 3560 } 3561 } 3562 break; 3563 } 3564 3565 case VisitorJob::RequiresExprVisitKind: { 3566 const RequiresExpr *E = cast<RequiresExprVisit>(&LI)->get(); 3567 for (const concepts::Requirement *R : E->getRequirements()) 3568 VisitConceptRequirement(*R); 3569 break; 3570 } 3571 3572 case VisitorJob::PostChildrenVisitKind: 3573 if (PostChildrenVisitor(Parent, ClientData)) 3574 return true; 3575 break; 3576 } 3577 } 3578 return false; 3579} 3580 3581bool CursorVisitor::Visit(const Stmt *S) { 3582 VisitorWorkList *WL = nullptr; 3583 if (!WorkListFreeList.empty()) { 3584 WL = WorkListFreeList.back(); 3585 WL->clear(); 3586 WorkListFreeList.pop_back(); 3587 } else { 3588 WL = new VisitorWorkList(); 3589 WorkListCache.push_back(WL); 3590 } 3591 EnqueueWorkList(*WL, S); 3592 bool result = RunVisitorWorkList(*WL); 3593 WorkListFreeList.push_back(WL); 3594 return result; 3595} 3596 3597namespace { 3598typedef SmallVector<SourceRange, 4> RefNamePieces; 3599RefNamePieces buildPieces(unsigned NameFlags, bool IsMemberRefExpr, 3600 const DeclarationNameInfo &NI, SourceRange QLoc, 3601 const SourceRange *TemplateArgsLoc = nullptr) { 3602 const bool WantQualifier = NameFlags & CXNameRange_WantQualifier; 3603 const bool WantTemplateArgs = NameFlags & CXNameRange_WantTemplateArgs; 3604 const bool WantSinglePiece = NameFlags & CXNameRange_WantSinglePiece; 3605 3606 const DeclarationName::NameKind Kind = NI.getName().getNameKind(); 3607 3608 RefNamePieces Pieces; 3609 3610 if (WantQualifier && QLoc.isValid()) 3611 Pieces.push_back(QLoc); 3612 3613 if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr) 3614 Pieces.push_back(NI.getLoc()); 3615 3616 if (WantTemplateArgs && TemplateArgsLoc && TemplateArgsLoc->isValid()) 3617 Pieces.push_back(*TemplateArgsLoc); 3618 3619 if (Kind == DeclarationName::CXXOperatorName) { 3620 Pieces.push_back(NI.getInfo().getCXXOperatorNameBeginLoc()); 3621 Pieces.push_back(NI.getInfo().getCXXOperatorNameEndLoc()); 3622 } 3623 3624 if (WantSinglePiece) { 3625 SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd()); 3626 Pieces.clear(); 3627 Pieces.push_back(R); 3628 } 3629 3630 return Pieces; 3631} 3632} // namespace 3633 3634//===----------------------------------------------------------------------===// 3635// Misc. API hooks. 3636//===----------------------------------------------------------------------===// 3637 3638namespace { 3639struct RegisterFatalErrorHandler { 3640 RegisterFatalErrorHandler() { 3641 clang_install_aborting_llvm_fatal_error_handler(); 3642 } 3643}; 3644} // namespace 3645 3646static llvm::ManagedStatic<RegisterFatalErrorHandler> 3647 RegisterFatalErrorHandlerOnce; 3648 3649CXIndex clang_createIndex(int excludeDeclarationsFromPCH, 3650 int displayDiagnostics) { 3651 // We use crash recovery to make some of our APIs more reliable, implicitly 3652 // enable it. 3653 if (!getenv("LIBCLANG_DISABLE_CRASH_RECOVERY")) 3654 llvm::CrashRecoveryContext::Enable(); 3655 3656 // Look through the managed static to trigger construction of the managed 3657 // static which registers our fatal error handler. This ensures it is only 3658 // registered once. 3659 (void)*RegisterFatalErrorHandlerOnce; 3660 3661 // Initialize targets for clang module support. 3662 llvm::InitializeAllTargets(); 3663 llvm::InitializeAllTargetMCs(); 3664 llvm::InitializeAllAsmPrinters(); 3665 llvm::InitializeAllAsmParsers(); 3666 3667 CIndexer *CIdxr = new CIndexer(); 3668 3669 if (excludeDeclarationsFromPCH) 3670 CIdxr->setOnlyLocalDecls(); 3671 if (displayDiagnostics) 3672 CIdxr->setDisplayDiagnostics(); 3673 3674 if (getenv("LIBCLANG_BGPRIO_INDEX")) 3675 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() | 3676 CXGlobalOpt_ThreadBackgroundPriorityForIndexing); 3677 if (getenv("LIBCLANG_BGPRIO_EDIT")) 3678 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() | 3679 CXGlobalOpt_ThreadBackgroundPriorityForEditing); 3680 3681 return CIdxr; 3682} 3683 3684void clang_disposeIndex(CXIndex CIdx) { 3685 if (CIdx) 3686 delete static_cast<CIndexer *>(CIdx); 3687} 3688 3689void clang_CXIndex_setGlobalOptions(CXIndex CIdx, unsigned options) { 3690 if (CIdx) 3691 static_cast<CIndexer *>(CIdx)->setCXGlobalOptFlags(options); 3692} 3693 3694unsigned clang_CXIndex_getGlobalOptions(CXIndex CIdx) { 3695 if (CIdx) 3696 return static_cast<CIndexer *>(CIdx)->getCXGlobalOptFlags(); 3697 return 0; 3698} 3699 3700void clang_CXIndex_setInvocationEmissionPathOption(CXIndex CIdx, 3701 const char *Path) { 3702 if (CIdx) 3703 static_cast<CIndexer *>(CIdx)->setInvocationEmissionPath(Path ? Path : ""); 3704} 3705 3706void clang_toggleCrashRecovery(unsigned isEnabled) { 3707 if (isEnabled) 3708 llvm::CrashRecoveryContext::Enable(); 3709 else 3710 llvm::CrashRecoveryContext::Disable(); 3711} 3712 3713CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx, 3714 const char *ast_filename) { 3715 CXTranslationUnit TU; 3716 enum CXErrorCode Result = 3717 clang_createTranslationUnit2(CIdx, ast_filename, &TU); 3718 (void)Result; 3719 assert((TU && Result == CXError_Success) || 3720 (!TU && Result != CXError_Success)); 3721 return TU; 3722} 3723 3724enum CXErrorCode clang_createTranslationUnit2(CXIndex CIdx, 3725 const char *ast_filename, 3726 CXTranslationUnit *out_TU) { 3727 if (out_TU) 3728 *out_TU = nullptr; 3729 3730 if (!CIdx || !ast_filename || !out_TU) 3731 return CXError_InvalidArguments; 3732 3733 LOG_FUNC_SECTION { *Log << ast_filename; } 3734 3735 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 3736 FileSystemOptions FileSystemOpts; 3737 3738 IntrusiveRefCntPtr<DiagnosticsEngine> Diags = 3739 CompilerInstance::createDiagnostics(new DiagnosticOptions()); 3740 std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile( 3741 ast_filename, CXXIdx->getPCHContainerOperations()->getRawReader(), 3742 ASTUnit::LoadEverything, Diags, FileSystemOpts, /*UseDebugInfo=*/false, 3743 CXXIdx->getOnlyLocalDecls(), CaptureDiagsKind::All, 3744 /*AllowASTWithCompilerErrors=*/true, 3745 /*UserFilesAreVolatile=*/true); 3746 *out_TU = MakeCXTranslationUnit(CXXIdx, std::move(AU)); 3747 return *out_TU ? CXError_Success : CXError_Failure; 3748} 3749 3750unsigned clang_defaultEditingTranslationUnitOptions() { 3751 return CXTranslationUnit_PrecompiledPreamble | 3752 CXTranslationUnit_CacheCompletionResults; 3753} 3754 3755CXTranslationUnit clang_createTranslationUnitFromSourceFile( 3756 CXIndex CIdx, const char *source_filename, int num_command_line_args, 3757 const char *const *command_line_args, unsigned num_unsaved_files, 3758 struct CXUnsavedFile *unsaved_files) { 3759 unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord; 3760 return clang_parseTranslationUnit(CIdx, source_filename, command_line_args, 3761 num_command_line_args, unsaved_files, 3762 num_unsaved_files, Options); 3763} 3764 3765static CXErrorCode 3766clang_parseTranslationUnit_Impl(CXIndex CIdx, const char *source_filename, 3767 const char *const *command_line_args, 3768 int num_command_line_args, 3769 ArrayRef<CXUnsavedFile> unsaved_files, 3770 unsigned options, CXTranslationUnit *out_TU) { 3771 // Set up the initial return values. 3772 if (out_TU) 3773 *out_TU = nullptr; 3774 3775 // Check arguments. 3776 if (!CIdx || !out_TU) 3777 return CXError_InvalidArguments; 3778 3779 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 3780 3781 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing)) 3782 setThreadBackgroundPriority(); 3783 3784 bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble; 3785 bool CreatePreambleOnFirstParse = 3786 options & CXTranslationUnit_CreatePreambleOnFirstParse; 3787 // FIXME: Add a flag for modules. 3788 TranslationUnitKind TUKind = (options & (CXTranslationUnit_Incomplete | 3789 CXTranslationUnit_SingleFileParse)) 3790 ? TU_Prefix 3791 : TU_Complete; 3792 bool CacheCodeCompletionResults = 3793 options & CXTranslationUnit_CacheCompletionResults; 3794 bool IncludeBriefCommentsInCodeCompletion = 3795 options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion; 3796 bool SingleFileParse = options & CXTranslationUnit_SingleFileParse; 3797 bool ForSerialization = options & CXTranslationUnit_ForSerialization; 3798 bool RetainExcludedCB = 3799 options & CXTranslationUnit_RetainExcludedConditionalBlocks; 3800 SkipFunctionBodiesScope SkipFunctionBodies = SkipFunctionBodiesScope::None; 3801 if (options & CXTranslationUnit_SkipFunctionBodies) { 3802 SkipFunctionBodies = 3803 (options & CXTranslationUnit_LimitSkipFunctionBodiesToPreamble) 3804 ? SkipFunctionBodiesScope::Preamble 3805 : SkipFunctionBodiesScope::PreambleAndMainFile; 3806 } 3807 3808 // Configure the diagnostics. 3809 std::unique_ptr<DiagnosticOptions> DiagOpts = CreateAndPopulateDiagOpts( 3810 llvm::ArrayRef(command_line_args, num_command_line_args)); 3811 IntrusiveRefCntPtr<DiagnosticsEngine> Diags( 3812 CompilerInstance::createDiagnostics(DiagOpts.release())); 3813 3814 if (options & CXTranslationUnit_KeepGoing) 3815 Diags->setFatalsAsError(true); 3816 3817 CaptureDiagsKind CaptureDiagnostics = CaptureDiagsKind::All; 3818 if (options & CXTranslationUnit_IgnoreNonErrorsFromIncludedFiles) 3819 CaptureDiagnostics = CaptureDiagsKind::AllWithoutNonErrorsFromIncludes; 3820 3821 // Recover resources if we crash before exiting this function. 3822 llvm::CrashRecoveryContextCleanupRegistrar< 3823 DiagnosticsEngine, 3824 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine>> 3825 DiagCleanup(Diags.get()); 3826 3827 std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles( 3828 new std::vector<ASTUnit::RemappedFile>()); 3829 3830 // Recover resources if we crash before exiting this function. 3831 llvm::CrashRecoveryContextCleanupRegistrar<std::vector<ASTUnit::RemappedFile>> 3832 RemappedCleanup(RemappedFiles.get()); 3833 3834 for (auto &UF : unsaved_files) { 3835 std::unique_ptr<llvm::MemoryBuffer> MB = 3836 llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename); 3837 RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release())); 3838 } 3839 3840 std::unique_ptr<std::vector<const char *>> Args( 3841 new std::vector<const char *>()); 3842 3843 // Recover resources if we crash before exiting this method. 3844 llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char *>> 3845 ArgsCleanup(Args.get()); 3846 3847 // Since the Clang C library is primarily used by batch tools dealing with 3848 // (often very broken) source code, where spell-checking can have a 3849 // significant negative impact on performance (particularly when 3850 // precompiled headers are involved), we disable it by default. 3851 // Only do this if we haven't found a spell-checking-related argument. 3852 bool FoundSpellCheckingArgument = false; 3853 for (int I = 0; I != num_command_line_args; ++I) { 3854 if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 || 3855 strcmp(command_line_args[I], "-fspell-checking") == 0) { 3856 FoundSpellCheckingArgument = true; 3857 break; 3858 } 3859 } 3860 Args->insert(Args->end(), command_line_args, 3861 command_line_args + num_command_line_args); 3862 3863 if (!FoundSpellCheckingArgument) 3864 Args->insert(Args->begin() + 1, "-fno-spell-checking"); 3865 3866 // The 'source_filename' argument is optional. If the caller does not 3867 // specify it then it is assumed that the source file is specified 3868 // in the actual argument list. 3869 // Put the source file after command_line_args otherwise if '-x' flag is 3870 // present it will be unused. 3871 if (source_filename) 3872 Args->push_back(source_filename); 3873 3874 // Do we need the detailed preprocessing record? 3875 if (options & CXTranslationUnit_DetailedPreprocessingRecord) { 3876 Args->push_back("-Xclang"); 3877 Args->push_back("-detailed-preprocessing-record"); 3878 } 3879 3880 // Suppress any editor placeholder diagnostics. 3881 Args->push_back("-fallow-editor-placeholders"); 3882 3883 unsigned NumErrors = Diags->getClient()->getNumErrors(); 3884 std::unique_ptr<ASTUnit> ErrUnit; 3885 // Unless the user specified that they want the preamble on the first parse 3886 // set it up to be created on the first reparse. This makes the first parse 3887 // faster, trading for a slower (first) reparse. 3888 unsigned PrecompilePreambleAfterNParses = 3889 !PrecompilePreamble ? 0 : 2 - CreatePreambleOnFirstParse; 3890 3891 LibclangInvocationReporter InvocationReporter( 3892 *CXXIdx, LibclangInvocationReporter::OperationKind::ParseOperation, 3893 options, llvm::ArrayRef(*Args), /*InvocationArgs=*/std::nullopt, 3894 unsaved_files); 3895 std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine( 3896 Args->data(), Args->data() + Args->size(), 3897 CXXIdx->getPCHContainerOperations(), Diags, 3898 CXXIdx->getClangResourcesPath(), CXXIdx->getOnlyLocalDecls(), 3899 CaptureDiagnostics, *RemappedFiles.get(), 3900 /*RemappedFilesKeepOriginalName=*/true, PrecompilePreambleAfterNParses, 3901 TUKind, CacheCodeCompletionResults, IncludeBriefCommentsInCodeCompletion, 3902 /*AllowPCHWithCompilerErrors=*/true, SkipFunctionBodies, SingleFileParse, 3903 /*UserFilesAreVolatile=*/true, ForSerialization, RetainExcludedCB, 3904 CXXIdx->getPCHContainerOperations()->getRawReader().getFormat(), 3905 &ErrUnit)); 3906 3907 // Early failures in LoadFromCommandLine may return with ErrUnit unset. 3908 if (!Unit && !ErrUnit) 3909 return CXError_ASTReadError; 3910 3911 if (NumErrors != Diags->getClient()->getNumErrors()) { 3912 // Make sure to check that 'Unit' is non-NULL. 3913 if (CXXIdx->getDisplayDiagnostics()) 3914 printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get()); 3915 } 3916 3917 if (isASTReadError(Unit ? Unit.get() : ErrUnit.get())) 3918 return CXError_ASTReadError; 3919 3920 *out_TU = MakeCXTranslationUnit(CXXIdx, std::move(Unit)); 3921 if (CXTranslationUnitImpl *TU = *out_TU) { 3922 TU->ParsingOptions = options; 3923 TU->Arguments.reserve(Args->size()); 3924 for (const char *Arg : *Args) 3925 TU->Arguments.push_back(Arg); 3926 return CXError_Success; 3927 } 3928 return CXError_Failure; 3929} 3930 3931CXTranslationUnit 3932clang_parseTranslationUnit(CXIndex CIdx, const char *source_filename, 3933 const char *const *command_line_args, 3934 int num_command_line_args, 3935 struct CXUnsavedFile *unsaved_files, 3936 unsigned num_unsaved_files, unsigned options) { 3937 CXTranslationUnit TU; 3938 enum CXErrorCode Result = clang_parseTranslationUnit2( 3939 CIdx, source_filename, command_line_args, num_command_line_args, 3940 unsaved_files, num_unsaved_files, options, &TU); 3941 (void)Result; 3942 assert((TU && Result == CXError_Success) || 3943 (!TU && Result != CXError_Success)); 3944 return TU; 3945} 3946 3947enum CXErrorCode clang_parseTranslationUnit2( 3948 CXIndex CIdx, const char *source_filename, 3949 const char *const *command_line_args, int num_command_line_args, 3950 struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, 3951 unsigned options, CXTranslationUnit *out_TU) { 3952 noteBottomOfStack(); 3953 SmallVector<const char *, 4> Args; 3954 Args.push_back("clang"); 3955 Args.append(command_line_args, command_line_args + num_command_line_args); 3956 return clang_parseTranslationUnit2FullArgv( 3957 CIdx, source_filename, Args.data(), Args.size(), unsaved_files, 3958 num_unsaved_files, options, out_TU); 3959} 3960 3961enum CXErrorCode clang_parseTranslationUnit2FullArgv( 3962 CXIndex CIdx, const char *source_filename, 3963 const char *const *command_line_args, int num_command_line_args, 3964 struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files, 3965 unsigned options, CXTranslationUnit *out_TU) { 3966 LOG_FUNC_SECTION { 3967 *Log << source_filename << ": "; 3968 for (int i = 0; i != num_command_line_args; ++i) 3969 *Log << command_line_args[i] << " "; 3970 } 3971 3972 if (num_unsaved_files && !unsaved_files) 3973 return CXError_InvalidArguments; 3974 3975 CXErrorCode result = CXError_Failure; 3976 auto ParseTranslationUnitImpl = [=, &result] { 3977 noteBottomOfStack(); 3978 result = clang_parseTranslationUnit_Impl( 3979 CIdx, source_filename, command_line_args, num_command_line_args, 3980 llvm::ArrayRef(unsaved_files, num_unsaved_files), options, out_TU); 3981 }; 3982 3983 llvm::CrashRecoveryContext CRC; 3984 3985 if (!RunSafely(CRC, ParseTranslationUnitImpl)) { 3986 fprintf(stderr, "libclang: crash detected during parsing: {\n"); 3987 fprintf(stderr, " 'source_filename' : '%s'\n", source_filename); 3988 fprintf(stderr, " 'command_line_args' : ["); 3989 for (int i = 0; i != num_command_line_args; ++i) { 3990 if (i) 3991 fprintf(stderr, ", "); 3992 fprintf(stderr, "'%s'", command_line_args[i]); 3993 } 3994 fprintf(stderr, "],\n"); 3995 fprintf(stderr, " 'unsaved_files' : ["); 3996 for (unsigned i = 0; i != num_unsaved_files; ++i) { 3997 if (i) 3998 fprintf(stderr, ", "); 3999 fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename, 4000 unsaved_files[i].Length); 4001 } 4002 fprintf(stderr, "],\n"); 4003 fprintf(stderr, " 'options' : %d,\n", options); 4004 fprintf(stderr, "}\n"); 4005 4006 return CXError_Crashed; 4007 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) { 4008 if (CXTranslationUnit *TU = out_TU) 4009 PrintLibclangResourceUsage(*TU); 4010 } 4011 4012 return result; 4013} 4014 4015CXString clang_Type_getObjCEncoding(CXType CT) { 4016 CXTranslationUnit tu = static_cast<CXTranslationUnit>(CT.data[1]); 4017 ASTContext &Ctx = getASTUnit(tu)->getASTContext(); 4018 std::string encoding; 4019 Ctx.getObjCEncodingForType(QualType::getFromOpaquePtr(CT.data[0]), encoding); 4020 4021 return cxstring::createDup(encoding); 4022} 4023 4024static const IdentifierInfo *getMacroIdentifier(CXCursor C) { 4025 if (C.kind == CXCursor_MacroDefinition) { 4026 if (const MacroDefinitionRecord *MDR = getCursorMacroDefinition(C)) 4027 return MDR->getName(); 4028 } else if (C.kind == CXCursor_MacroExpansion) { 4029 MacroExpansionCursor ME = getCursorMacroExpansion(C); 4030 return ME.getName(); 4031 } 4032 return nullptr; 4033} 4034 4035unsigned clang_Cursor_isMacroFunctionLike(CXCursor C) { 4036 const IdentifierInfo *II = getMacroIdentifier(C); 4037 if (!II) { 4038 return false; 4039 } 4040 ASTUnit *ASTU = getCursorASTUnit(C); 4041 Preprocessor &PP = ASTU->getPreprocessor(); 4042 if (const MacroInfo *MI = PP.getMacroInfo(II)) 4043 return MI->isFunctionLike(); 4044 return false; 4045} 4046 4047unsigned clang_Cursor_isMacroBuiltin(CXCursor C) { 4048 const IdentifierInfo *II = getMacroIdentifier(C); 4049 if (!II) { 4050 return false; 4051 } 4052 ASTUnit *ASTU = getCursorASTUnit(C); 4053 Preprocessor &PP = ASTU->getPreprocessor(); 4054 if (const MacroInfo *MI = PP.getMacroInfo(II)) 4055 return MI->isBuiltinMacro(); 4056 return false; 4057} 4058 4059unsigned clang_Cursor_isFunctionInlined(CXCursor C) { 4060 const Decl *D = getCursorDecl(C); 4061 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D); 4062 if (!FD) { 4063 return false; 4064 } 4065 return FD->isInlined(); 4066} 4067 4068static StringLiteral *getCFSTR_value(CallExpr *callExpr) { 4069 if (callExpr->getNumArgs() != 1) { 4070 return nullptr; 4071 } 4072 4073 StringLiteral *S = nullptr; 4074 auto *arg = callExpr->getArg(0); 4075 if (arg->getStmtClass() == Stmt::ImplicitCastExprClass) { 4076 ImplicitCastExpr *I = static_cast<ImplicitCastExpr *>(arg); 4077 auto *subExpr = I->getSubExprAsWritten(); 4078 4079 if (subExpr->getStmtClass() != Stmt::StringLiteralClass) { 4080 return nullptr; 4081 } 4082 4083 S = static_cast<StringLiteral *>(I->getSubExprAsWritten()); 4084 } else if (arg->getStmtClass() == Stmt::StringLiteralClass) { 4085 S = static_cast<StringLiteral *>(callExpr->getArg(0)); 4086 } else { 4087 return nullptr; 4088 } 4089 return S; 4090} 4091 4092struct ExprEvalResult { 4093 CXEvalResultKind EvalType; 4094 union { 4095 unsigned long long unsignedVal; 4096 long long intVal; 4097 double floatVal; 4098 char *stringVal; 4099 } EvalData; 4100 bool IsUnsignedInt; 4101 ~ExprEvalResult() { 4102 if (EvalType != CXEval_UnExposed && EvalType != CXEval_Float && 4103 EvalType != CXEval_Int) { 4104 delete[] EvalData.stringVal; 4105 } 4106 } 4107}; 4108 4109void clang_EvalResult_dispose(CXEvalResult E) { 4110 delete static_cast<ExprEvalResult *>(E); 4111} 4112 4113CXEvalResultKind clang_EvalResult_getKind(CXEvalResult E) { 4114 if (!E) { 4115 return CXEval_UnExposed; 4116 } 4117 return ((ExprEvalResult *)E)->EvalType; 4118} 4119 4120int clang_EvalResult_getAsInt(CXEvalResult E) { 4121 return clang_EvalResult_getAsLongLong(E); 4122} 4123 4124long long clang_EvalResult_getAsLongLong(CXEvalResult E) { 4125 if (!E) { 4126 return 0; 4127 } 4128 ExprEvalResult *Result = (ExprEvalResult *)E; 4129 if (Result->IsUnsignedInt) 4130 return Result->EvalData.unsignedVal; 4131 return Result->EvalData.intVal; 4132} 4133 4134unsigned clang_EvalResult_isUnsignedInt(CXEvalResult E) { 4135 return ((ExprEvalResult *)E)->IsUnsignedInt; 4136} 4137 4138unsigned long long clang_EvalResult_getAsUnsigned(CXEvalResult E) { 4139 if (!E) { 4140 return 0; 4141 } 4142 4143 ExprEvalResult *Result = (ExprEvalResult *)E; 4144 if (Result->IsUnsignedInt) 4145 return Result->EvalData.unsignedVal; 4146 return Result->EvalData.intVal; 4147} 4148 4149double clang_EvalResult_getAsDouble(CXEvalResult E) { 4150 if (!E) { 4151 return 0; 4152 } 4153 return ((ExprEvalResult *)E)->EvalData.floatVal; 4154} 4155 4156const char *clang_EvalResult_getAsStr(CXEvalResult E) { 4157 if (!E) { 4158 return nullptr; 4159 } 4160 return ((ExprEvalResult *)E)->EvalData.stringVal; 4161} 4162 4163static const ExprEvalResult *evaluateExpr(Expr *expr, CXCursor C) { 4164 Expr::EvalResult ER; 4165 ASTContext &ctx = getCursorContext(C); 4166 if (!expr) 4167 return nullptr; 4168 4169 expr = expr->IgnoreParens(); 4170 if (expr->isValueDependent()) 4171 return nullptr; 4172 if (!expr->EvaluateAsRValue(ER, ctx)) 4173 return nullptr; 4174 4175 QualType rettype; 4176 CallExpr *callExpr; 4177 auto result = std::make_unique<ExprEvalResult>(); 4178 result->EvalType = CXEval_UnExposed; 4179 result->IsUnsignedInt = false; 4180 4181 if (ER.Val.isInt()) { 4182 result->EvalType = CXEval_Int; 4183 4184 auto &val = ER.Val.getInt(); 4185 if (val.isUnsigned()) { 4186 result->IsUnsignedInt = true; 4187 result->EvalData.unsignedVal = val.getZExtValue(); 4188 } else { 4189 result->EvalData.intVal = val.getExtValue(); 4190 } 4191 4192 return result.release(); 4193 } 4194 4195 if (ER.Val.isFloat()) { 4196 llvm::SmallVector<char, 100> Buffer; 4197 ER.Val.getFloat().toString(Buffer); 4198 std::string floatStr(Buffer.data(), Buffer.size()); 4199 result->EvalType = CXEval_Float; 4200 bool ignored; 4201 llvm::APFloat apFloat = ER.Val.getFloat(); 4202 apFloat.convert(llvm::APFloat::IEEEdouble(), 4203 llvm::APFloat::rmNearestTiesToEven, &ignored); 4204 result->EvalData.floatVal = apFloat.convertToDouble(); 4205 return result.release(); 4206 } 4207 4208 if (expr->getStmtClass() == Stmt::ImplicitCastExprClass) { 4209 const auto *I = cast<ImplicitCastExpr>(expr); 4210 auto *subExpr = I->getSubExprAsWritten(); 4211 if (subExpr->getStmtClass() == Stmt::StringLiteralClass || 4212 subExpr->getStmtClass() == Stmt::ObjCStringLiteralClass) { 4213 const StringLiteral *StrE = nullptr; 4214 const ObjCStringLiteral *ObjCExpr; 4215 ObjCExpr = dyn_cast<ObjCStringLiteral>(subExpr); 4216 4217 if (ObjCExpr) { 4218 StrE = ObjCExpr->getString(); 4219 result->EvalType = CXEval_ObjCStrLiteral; 4220 } else { 4221 StrE = cast<StringLiteral>(I->getSubExprAsWritten()); 4222 result->EvalType = CXEval_StrLiteral; 4223 } 4224 4225 std::string strRef(StrE->getString().str()); 4226 result->EvalData.stringVal = new char[strRef.size() + 1]; 4227 strncpy((char *)result->EvalData.stringVal, strRef.c_str(), 4228 strRef.size()); 4229 result->EvalData.stringVal[strRef.size()] = '\0'; 4230 return result.release(); 4231 } 4232 } else if (expr->getStmtClass() == Stmt::ObjCStringLiteralClass || 4233 expr->getStmtClass() == Stmt::StringLiteralClass) { 4234 const StringLiteral *StrE = nullptr; 4235 const ObjCStringLiteral *ObjCExpr; 4236 ObjCExpr = dyn_cast<ObjCStringLiteral>(expr); 4237 4238 if (ObjCExpr) { 4239 StrE = ObjCExpr->getString(); 4240 result->EvalType = CXEval_ObjCStrLiteral; 4241 } else { 4242 StrE = cast<StringLiteral>(expr); 4243 result->EvalType = CXEval_StrLiteral; 4244 } 4245 4246 std::string strRef(StrE->getString().str()); 4247 result->EvalData.stringVal = new char[strRef.size() + 1]; 4248 strncpy((char *)result->EvalData.stringVal, strRef.c_str(), strRef.size()); 4249 result->EvalData.stringVal[strRef.size()] = '\0'; 4250 return result.release(); 4251 } 4252 4253 if (expr->getStmtClass() == Stmt::CStyleCastExprClass) { 4254 CStyleCastExpr *CC = static_cast<CStyleCastExpr *>(expr); 4255 4256 rettype = CC->getType(); 4257 if (rettype.getAsString() == "CFStringRef" && 4258 CC->getSubExpr()->getStmtClass() == Stmt::CallExprClass) { 4259 4260 callExpr = static_cast<CallExpr *>(CC->getSubExpr()); 4261 StringLiteral *S = getCFSTR_value(callExpr); 4262 if (S) { 4263 std::string strLiteral(S->getString().str()); 4264 result->EvalType = CXEval_CFStr; 4265 4266 result->EvalData.stringVal = new char[strLiteral.size() + 1]; 4267 strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(), 4268 strLiteral.size()); 4269 result->EvalData.stringVal[strLiteral.size()] = '\0'; 4270 return result.release(); 4271 } 4272 } 4273 4274 } else if (expr->getStmtClass() == Stmt::CallExprClass) { 4275 callExpr = static_cast<CallExpr *>(expr); 4276 rettype = callExpr->getCallReturnType(ctx); 4277 4278 if (rettype->isVectorType() || callExpr->getNumArgs() > 1) 4279 return nullptr; 4280 4281 if (rettype->isIntegralType(ctx) || rettype->isRealFloatingType()) { 4282 if (callExpr->getNumArgs() == 1 && 4283 !callExpr->getArg(0)->getType()->isIntegralType(ctx)) 4284 return nullptr; 4285 } else if (rettype.getAsString() == "CFStringRef") { 4286 4287 StringLiteral *S = getCFSTR_value(callExpr); 4288 if (S) { 4289 std::string strLiteral(S->getString().str()); 4290 result->EvalType = CXEval_CFStr; 4291 result->EvalData.stringVal = new char[strLiteral.size() + 1]; 4292 strncpy((char *)result->EvalData.stringVal, strLiteral.c_str(), 4293 strLiteral.size()); 4294 result->EvalData.stringVal[strLiteral.size()] = '\0'; 4295 return result.release(); 4296 } 4297 } 4298 } else if (expr->getStmtClass() == Stmt::DeclRefExprClass) { 4299 DeclRefExpr *D = static_cast<DeclRefExpr *>(expr); 4300 ValueDecl *V = D->getDecl(); 4301 if (V->getKind() == Decl::Function) { 4302 std::string strName = V->getNameAsString(); 4303 result->EvalType = CXEval_Other; 4304 result->EvalData.stringVal = new char[strName.size() + 1]; 4305 strncpy(result->EvalData.stringVal, strName.c_str(), strName.size()); 4306 result->EvalData.stringVal[strName.size()] = '\0'; 4307 return result.release(); 4308 } 4309 } 4310 4311 return nullptr; 4312} 4313 4314static const Expr *evaluateDeclExpr(const Decl *D) { 4315 if (!D) 4316 return nullptr; 4317 if (auto *Var = dyn_cast<VarDecl>(D)) 4318 return Var->getInit(); 4319 else if (auto *Field = dyn_cast<FieldDecl>(D)) 4320 return Field->getInClassInitializer(); 4321 return nullptr; 4322} 4323 4324static const Expr *evaluateCompoundStmtExpr(const CompoundStmt *CS) { 4325 assert(CS && "invalid compound statement"); 4326 for (auto *bodyIterator : CS->body()) { 4327 if (const auto *E = dyn_cast<Expr>(bodyIterator)) 4328 return E; 4329 } 4330 return nullptr; 4331} 4332 4333CXEvalResult clang_Cursor_Evaluate(CXCursor C) { 4334 const Expr *E = nullptr; 4335 if (clang_getCursorKind(C) == CXCursor_CompoundStmt) 4336 E = evaluateCompoundStmtExpr(cast<CompoundStmt>(getCursorStmt(C))); 4337 else if (clang_isDeclaration(C.kind)) 4338 E = evaluateDeclExpr(getCursorDecl(C)); 4339 else if (clang_isExpression(C.kind)) 4340 E = getCursorExpr(C); 4341 if (E) 4342 return const_cast<CXEvalResult>( 4343 reinterpret_cast<const void *>(evaluateExpr(const_cast<Expr *>(E), C))); 4344 return nullptr; 4345} 4346 4347unsigned clang_Cursor_hasAttrs(CXCursor C) { 4348 const Decl *D = getCursorDecl(C); 4349 if (!D) { 4350 return 0; 4351 } 4352 4353 if (D->hasAttrs()) { 4354 return 1; 4355 } 4356 4357 return 0; 4358} 4359unsigned clang_defaultSaveOptions(CXTranslationUnit TU) { 4360 return CXSaveTranslationUnit_None; 4361} 4362 4363static CXSaveError clang_saveTranslationUnit_Impl(CXTranslationUnit TU, 4364 const char *FileName, 4365 unsigned options) { 4366 CIndexer *CXXIdx = TU->CIdx; 4367 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing)) 4368 setThreadBackgroundPriority(); 4369 4370 bool hadError = cxtu::getASTUnit(TU)->Save(FileName); 4371 return hadError ? CXSaveError_Unknown : CXSaveError_None; 4372} 4373 4374int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName, 4375 unsigned options) { 4376 LOG_FUNC_SECTION { *Log << TU << ' ' << FileName; } 4377 4378 if (isNotUsableTU(TU)) { 4379 LOG_BAD_TU(TU); 4380 return CXSaveError_InvalidTU; 4381 } 4382 4383 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4384 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 4385 if (!CXXUnit->hasSema()) 4386 return CXSaveError_InvalidTU; 4387 4388 CXSaveError result; 4389 auto SaveTranslationUnitImpl = [=, &result]() { 4390 result = clang_saveTranslationUnit_Impl(TU, FileName, options); 4391 }; 4392 4393 if (!CXXUnit->getDiagnostics().hasUnrecoverableErrorOccurred()) { 4394 SaveTranslationUnitImpl(); 4395 4396 if (getenv("LIBCLANG_RESOURCE_USAGE")) 4397 PrintLibclangResourceUsage(TU); 4398 4399 return result; 4400 } 4401 4402 // We have an AST that has invalid nodes due to compiler errors. 4403 // Use a crash recovery thread for protection. 4404 4405 llvm::CrashRecoveryContext CRC; 4406 4407 if (!RunSafely(CRC, SaveTranslationUnitImpl)) { 4408 fprintf(stderr, "libclang: crash detected during AST saving: {\n"); 4409 fprintf(stderr, " 'filename' : '%s'\n", FileName); 4410 fprintf(stderr, " 'options' : %d,\n", options); 4411 fprintf(stderr, "}\n"); 4412 4413 return CXSaveError_Unknown; 4414 4415 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) { 4416 PrintLibclangResourceUsage(TU); 4417 } 4418 4419 return result; 4420} 4421 4422void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) { 4423 if (CTUnit) { 4424 // If the translation unit has been marked as unsafe to free, just discard 4425 // it. 4426 ASTUnit *Unit = cxtu::getASTUnit(CTUnit); 4427 if (Unit && Unit->isUnsafeToFree()) 4428 return; 4429 4430 delete cxtu::getASTUnit(CTUnit); 4431 delete CTUnit->StringPool; 4432 delete static_cast<CXDiagnosticSetImpl *>(CTUnit->Diagnostics); 4433 disposeOverridenCXCursorsPool(CTUnit->OverridenCursorsPool); 4434 delete CTUnit->CommentToXML; 4435 delete CTUnit; 4436 } 4437} 4438 4439unsigned clang_suspendTranslationUnit(CXTranslationUnit CTUnit) { 4440 if (CTUnit) { 4441 ASTUnit *Unit = cxtu::getASTUnit(CTUnit); 4442 4443 if (Unit && Unit->isUnsafeToFree()) 4444 return false; 4445 4446 Unit->ResetForParse(); 4447 return true; 4448 } 4449 4450 return false; 4451} 4452 4453unsigned clang_defaultReparseOptions(CXTranslationUnit TU) { 4454 return CXReparse_None; 4455} 4456 4457static CXErrorCode 4458clang_reparseTranslationUnit_Impl(CXTranslationUnit TU, 4459 ArrayRef<CXUnsavedFile> unsaved_files, 4460 unsigned options) { 4461 // Check arguments. 4462 if (isNotUsableTU(TU)) { 4463 LOG_BAD_TU(TU); 4464 return CXError_InvalidArguments; 4465 } 4466 4467 // Reset the associated diagnostics. 4468 delete static_cast<CXDiagnosticSetImpl *>(TU->Diagnostics); 4469 TU->Diagnostics = nullptr; 4470 4471 CIndexer *CXXIdx = TU->CIdx; 4472 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 4473 setThreadBackgroundPriority(); 4474 4475 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4476 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 4477 4478 std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles( 4479 new std::vector<ASTUnit::RemappedFile>()); 4480 4481 // Recover resources if we crash before exiting this function. 4482 llvm::CrashRecoveryContextCleanupRegistrar<std::vector<ASTUnit::RemappedFile>> 4483 RemappedCleanup(RemappedFiles.get()); 4484 4485 for (auto &UF : unsaved_files) { 4486 std::unique_ptr<llvm::MemoryBuffer> MB = 4487 llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename); 4488 RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release())); 4489 } 4490 4491 if (!CXXUnit->Reparse(CXXIdx->getPCHContainerOperations(), 4492 *RemappedFiles.get())) 4493 return CXError_Success; 4494 if (isASTReadError(CXXUnit)) 4495 return CXError_ASTReadError; 4496 return CXError_Failure; 4497} 4498 4499int clang_reparseTranslationUnit(CXTranslationUnit TU, 4500 unsigned num_unsaved_files, 4501 struct CXUnsavedFile *unsaved_files, 4502 unsigned options) { 4503 LOG_FUNC_SECTION { *Log << TU; } 4504 4505 if (num_unsaved_files && !unsaved_files) 4506 return CXError_InvalidArguments; 4507 4508 CXErrorCode result; 4509 auto ReparseTranslationUnitImpl = [=, &result]() { 4510 result = clang_reparseTranslationUnit_Impl( 4511 TU, llvm::ArrayRef(unsaved_files, num_unsaved_files), options); 4512 }; 4513 4514 llvm::CrashRecoveryContext CRC; 4515 4516 if (!RunSafely(CRC, ReparseTranslationUnitImpl)) { 4517 fprintf(stderr, "libclang: crash detected during reparsing\n"); 4518 cxtu::getASTUnit(TU)->setUnsafeToFree(true); 4519 return CXError_Crashed; 4520 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) 4521 PrintLibclangResourceUsage(TU); 4522 4523 return result; 4524} 4525 4526CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) { 4527 if (isNotUsableTU(CTUnit)) { 4528 LOG_BAD_TU(CTUnit); 4529 return cxstring::createEmpty(); 4530 } 4531 4532 ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit); 4533 return cxstring::createDup(CXXUnit->getOriginalSourceFileName()); 4534} 4535 4536CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) { 4537 if (isNotUsableTU(TU)) { 4538 LOG_BAD_TU(TU); 4539 return clang_getNullCursor(); 4540 } 4541 4542 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4543 return MakeCXCursor(CXXUnit->getASTContext().getTranslationUnitDecl(), TU); 4544} 4545 4546CXTargetInfo clang_getTranslationUnitTargetInfo(CXTranslationUnit CTUnit) { 4547 if (isNotUsableTU(CTUnit)) { 4548 LOG_BAD_TU(CTUnit); 4549 return nullptr; 4550 } 4551 4552 CXTargetInfoImpl *impl = new CXTargetInfoImpl(); 4553 impl->TranslationUnit = CTUnit; 4554 return impl; 4555} 4556 4557CXString clang_TargetInfo_getTriple(CXTargetInfo TargetInfo) { 4558 if (!TargetInfo) 4559 return cxstring::createEmpty(); 4560 4561 CXTranslationUnit CTUnit = TargetInfo->TranslationUnit; 4562 assert(!isNotUsableTU(CTUnit) && 4563 "Unexpected unusable translation unit in TargetInfo"); 4564 4565 ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit); 4566 std::string Triple = 4567 CXXUnit->getASTContext().getTargetInfo().getTriple().normalize(); 4568 return cxstring::createDup(Triple); 4569} 4570 4571int clang_TargetInfo_getPointerWidth(CXTargetInfo TargetInfo) { 4572 if (!TargetInfo) 4573 return -1; 4574 4575 CXTranslationUnit CTUnit = TargetInfo->TranslationUnit; 4576 assert(!isNotUsableTU(CTUnit) && 4577 "Unexpected unusable translation unit in TargetInfo"); 4578 4579 ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit); 4580 return CXXUnit->getASTContext().getTargetInfo().getMaxPointerWidth(); 4581} 4582 4583void clang_TargetInfo_dispose(CXTargetInfo TargetInfo) { 4584 if (!TargetInfo) 4585 return; 4586 4587 delete TargetInfo; 4588} 4589 4590//===----------------------------------------------------------------------===// 4591// CXFile Operations. 4592//===----------------------------------------------------------------------===// 4593 4594CXString clang_getFileName(CXFile SFile) { 4595 if (!SFile) 4596 return cxstring::createNull(); 4597 4598 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 4599 return cxstring::createRef(FEnt->getName()); 4600} 4601 4602time_t clang_getFileTime(CXFile SFile) { 4603 if (!SFile) 4604 return 0; 4605 4606 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 4607 return FEnt->getModificationTime(); 4608} 4609 4610CXFile clang_getFile(CXTranslationUnit TU, const char *file_name) { 4611 if (isNotUsableTU(TU)) { 4612 LOG_BAD_TU(TU); 4613 return nullptr; 4614 } 4615 4616 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4617 4618 FileManager &FMgr = CXXUnit->getFileManager(); 4619 auto File = FMgr.getFile(file_name); 4620 if (!File) 4621 return nullptr; 4622 return const_cast<FileEntry *>(*File); 4623} 4624 4625const char *clang_getFileContents(CXTranslationUnit TU, CXFile file, 4626 size_t *size) { 4627 if (isNotUsableTU(TU)) { 4628 LOG_BAD_TU(TU); 4629 return nullptr; 4630 } 4631 4632 const SourceManager &SM = cxtu::getASTUnit(TU)->getSourceManager(); 4633 FileID fid = SM.translateFile(static_cast<FileEntry *>(file)); 4634 std::optional<llvm::MemoryBufferRef> buf = SM.getBufferOrNone(fid); 4635 if (!buf) { 4636 if (size) 4637 *size = 0; 4638 return nullptr; 4639 } 4640 if (size) 4641 *size = buf->getBufferSize(); 4642 return buf->getBufferStart(); 4643} 4644 4645unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit TU, CXFile file) { 4646 if (isNotUsableTU(TU)) { 4647 LOG_BAD_TU(TU); 4648 return 0; 4649 } 4650 4651 if (!file) 4652 return 0; 4653 4654 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 4655 FileEntry *FEnt = static_cast<FileEntry *>(file); 4656 return CXXUnit->getPreprocessor() 4657 .getHeaderSearchInfo() 4658 .isFileMultipleIncludeGuarded(FEnt); 4659} 4660 4661int clang_getFileUniqueID(CXFile file, CXFileUniqueID *outID) { 4662 if (!file || !outID) 4663 return 1; 4664 4665 FileEntry *FEnt = static_cast<FileEntry *>(file); 4666 const llvm::sys::fs::UniqueID &ID = FEnt->getUniqueID(); 4667 outID->data[0] = ID.getDevice(); 4668 outID->data[1] = ID.getFile(); 4669 outID->data[2] = FEnt->getModificationTime(); 4670 return 0; 4671} 4672 4673int clang_File_isEqual(CXFile file1, CXFile file2) { 4674 if (file1 == file2) 4675 return true; 4676 4677 if (!file1 || !file2) 4678 return false; 4679 4680 FileEntry *FEnt1 = static_cast<FileEntry *>(file1); 4681 FileEntry *FEnt2 = static_cast<FileEntry *>(file2); 4682 return FEnt1->getUniqueID() == FEnt2->getUniqueID(); 4683} 4684 4685CXString clang_File_tryGetRealPathName(CXFile SFile) { 4686 if (!SFile) 4687 return cxstring::createNull(); 4688 4689 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 4690 return cxstring::createRef(FEnt->tryGetRealPathName()); 4691} 4692 4693//===----------------------------------------------------------------------===// 4694// CXCursor Operations. 4695//===----------------------------------------------------------------------===// 4696 4697static const Decl *getDeclFromExpr(const Stmt *E) { 4698 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 4699 return getDeclFromExpr(CE->getSubExpr()); 4700 4701 if (const DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E)) 4702 return RefExpr->getDecl(); 4703 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) 4704 return ME->getMemberDecl(); 4705 if (const ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E)) 4706 return RE->getDecl(); 4707 if (const ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E)) { 4708 if (PRE->isExplicitProperty()) 4709 return PRE->getExplicitProperty(); 4710 // It could be messaging both getter and setter as in: 4711 // ++myobj.myprop; 4712 // in which case prefer to associate the setter since it is less obvious 4713 // from inspecting the source that the setter is going to get called. 4714 if (PRE->isMessagingSetter()) 4715 return PRE->getImplicitPropertySetter(); 4716 return PRE->getImplicitPropertyGetter(); 4717 } 4718 if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) 4719 return getDeclFromExpr(POE->getSyntacticForm()); 4720 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) 4721 if (Expr *Src = OVE->getSourceExpr()) 4722 return getDeclFromExpr(Src); 4723 4724 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) 4725 return getDeclFromExpr(CE->getCallee()); 4726 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E)) 4727 if (!CE->isElidable()) 4728 return CE->getConstructor(); 4729 if (const CXXInheritedCtorInitExpr *CE = 4730 dyn_cast<CXXInheritedCtorInitExpr>(E)) 4731 return CE->getConstructor(); 4732 if (const ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E)) 4733 return OME->getMethodDecl(); 4734 4735 if (const ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E)) 4736 return PE->getProtocol(); 4737 if (const SubstNonTypeTemplateParmPackExpr *NTTP = 4738 dyn_cast<SubstNonTypeTemplateParmPackExpr>(E)) 4739 return NTTP->getParameterPack(); 4740 if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 4741 if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) || 4742 isa<ParmVarDecl>(SizeOfPack->getPack())) 4743 return SizeOfPack->getPack(); 4744 4745 return nullptr; 4746} 4747 4748static SourceLocation getLocationFromExpr(const Expr *E) { 4749 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 4750 return getLocationFromExpr(CE->getSubExpr()); 4751 4752 if (const ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E)) 4753 return /*FIXME:*/ Msg->getLeftLoc(); 4754 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 4755 return DRE->getLocation(); 4756 if (const MemberExpr *Member = dyn_cast<MemberExpr>(E)) 4757 return Member->getMemberLoc(); 4758 if (const ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E)) 4759 return Ivar->getLocation(); 4760 if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 4761 return SizeOfPack->getPackLoc(); 4762 if (const ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E)) 4763 return PropRef->getLocation(); 4764 4765 return E->getBeginLoc(); 4766} 4767 4768extern "C" { 4769 4770unsigned clang_visitChildren(CXCursor parent, CXCursorVisitor visitor, 4771 CXClientData client_data) { 4772 CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data, 4773 /*VisitPreprocessorLast=*/false); 4774 return CursorVis.VisitChildren(parent); 4775} 4776 4777#ifndef __has_feature 4778#define __has_feature(x) 0 4779#endif 4780#if __has_feature(blocks) 4781typedef enum CXChildVisitResult (^CXCursorVisitorBlock)(CXCursor cursor, 4782 CXCursor parent); 4783 4784static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 4785 CXClientData client_data) { 4786 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 4787 return block(cursor, parent); 4788} 4789#else 4790// If we are compiled with a compiler that doesn't have native blocks support, 4791// define and call the block manually, so the 4792typedef struct _CXChildVisitResult { 4793 void *isa; 4794 int flags; 4795 int reserved; 4796 enum CXChildVisitResult (*invoke)(struct _CXChildVisitResult *, CXCursor, 4797 CXCursor); 4798} * CXCursorVisitorBlock; 4799 4800static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 4801 CXClientData client_data) { 4802 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 4803 return block->invoke(block, cursor, parent); 4804} 4805#endif 4806 4807unsigned clang_visitChildrenWithBlock(CXCursor parent, 4808 CXCursorVisitorBlock block) { 4809 return clang_visitChildren(parent, visitWithBlock, block); 4810} 4811 4812static CXString getDeclSpelling(const Decl *D) { 4813 if (!D) 4814 return cxstring::createEmpty(); 4815 4816 const NamedDecl *ND = dyn_cast<NamedDecl>(D); 4817 if (!ND) { 4818 if (const ObjCPropertyImplDecl *PropImpl = 4819 dyn_cast<ObjCPropertyImplDecl>(D)) 4820 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 4821 return cxstring::createDup(Property->getIdentifier()->getName()); 4822 4823 if (const ImportDecl *ImportD = dyn_cast<ImportDecl>(D)) 4824 if (Module *Mod = ImportD->getImportedModule()) 4825 return cxstring::createDup(Mod->getFullModuleName()); 4826 4827 return cxstring::createEmpty(); 4828 } 4829 4830 if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND)) 4831 return cxstring::createDup(OMD->getSelector().getAsString()); 4832 4833 if (const ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND)) 4834 // No, this isn't the same as the code below. getIdentifier() is non-virtual 4835 // and returns different names. NamedDecl returns the class name and 4836 // ObjCCategoryImplDecl returns the category name. 4837 return cxstring::createRef(CIMP->getIdentifier()->getNameStart()); 4838 4839 if (isa<UsingDirectiveDecl>(D)) 4840 return cxstring::createEmpty(); 4841 4842 SmallString<1024> S; 4843 llvm::raw_svector_ostream os(S); 4844 ND->printName(os); 4845 4846 return cxstring::createDup(os.str()); 4847} 4848 4849CXString clang_getCursorSpelling(CXCursor C) { 4850 if (clang_isTranslationUnit(C.kind)) 4851 return clang_getTranslationUnitSpelling(getCursorTU(C)); 4852 4853 if (clang_isReference(C.kind)) { 4854 switch (C.kind) { 4855 case CXCursor_ObjCSuperClassRef: { 4856 const ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first; 4857 return cxstring::createRef(Super->getIdentifier()->getNameStart()); 4858 } 4859 case CXCursor_ObjCClassRef: { 4860 const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first; 4861 return cxstring::createRef(Class->getIdentifier()->getNameStart()); 4862 } 4863 case CXCursor_ObjCProtocolRef: { 4864 const ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first; 4865 assert(OID && "getCursorSpelling(): Missing protocol decl"); 4866 return cxstring::createRef(OID->getIdentifier()->getNameStart()); 4867 } 4868 case CXCursor_CXXBaseSpecifier: { 4869 const CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C); 4870 return cxstring::createDup(B->getType().getAsString()); 4871 } 4872 case CXCursor_TypeRef: { 4873 const TypeDecl *Type = getCursorTypeRef(C).first; 4874 assert(Type && "Missing type decl"); 4875 4876 return cxstring::createDup( 4877 getCursorContext(C).getTypeDeclType(Type).getAsString()); 4878 } 4879 case CXCursor_TemplateRef: { 4880 const TemplateDecl *Template = getCursorTemplateRef(C).first; 4881 assert(Template && "Missing template decl"); 4882 4883 return cxstring::createDup(Template->getNameAsString()); 4884 } 4885 4886 case CXCursor_NamespaceRef: { 4887 const NamedDecl *NS = getCursorNamespaceRef(C).first; 4888 assert(NS && "Missing namespace decl"); 4889 4890 return cxstring::createDup(NS->getNameAsString()); 4891 } 4892 4893 case CXCursor_MemberRef: { 4894 const FieldDecl *Field = getCursorMemberRef(C).first; 4895 assert(Field && "Missing member decl"); 4896 4897 return cxstring::createDup(Field->getNameAsString()); 4898 } 4899 4900 case CXCursor_LabelRef: { 4901 const LabelStmt *Label = getCursorLabelRef(C).first; 4902 assert(Label && "Missing label"); 4903 4904 return cxstring::createRef(Label->getName()); 4905 } 4906 4907 case CXCursor_OverloadedDeclRef: { 4908 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 4909 if (const Decl *D = Storage.dyn_cast<const Decl *>()) { 4910 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) 4911 return cxstring::createDup(ND->getNameAsString()); 4912 return cxstring::createEmpty(); 4913 } 4914 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>()) 4915 return cxstring::createDup(E->getName().getAsString()); 4916 OverloadedTemplateStorage *Ovl = 4917 Storage.get<OverloadedTemplateStorage *>(); 4918 if (Ovl->size() == 0) 4919 return cxstring::createEmpty(); 4920 return cxstring::createDup((*Ovl->begin())->getNameAsString()); 4921 } 4922 4923 case CXCursor_VariableRef: { 4924 const VarDecl *Var = getCursorVariableRef(C).first; 4925 assert(Var && "Missing variable decl"); 4926 4927 return cxstring::createDup(Var->getNameAsString()); 4928 } 4929 4930 default: 4931 return cxstring::createRef("<not implemented>"); 4932 } 4933 } 4934 4935 if (clang_isExpression(C.kind)) { 4936 const Expr *E = getCursorExpr(C); 4937 4938 if (C.kind == CXCursor_ObjCStringLiteral || 4939 C.kind == CXCursor_StringLiteral) { 4940 const StringLiteral *SLit; 4941 if (const ObjCStringLiteral *OSL = dyn_cast<ObjCStringLiteral>(E)) { 4942 SLit = OSL->getString(); 4943 } else { 4944 SLit = cast<StringLiteral>(E); 4945 } 4946 SmallString<256> Buf; 4947 llvm::raw_svector_ostream OS(Buf); 4948 SLit->outputString(OS); 4949 return cxstring::createDup(OS.str()); 4950 } 4951 4952 const Decl *D = getDeclFromExpr(getCursorExpr(C)); 4953 if (D) 4954 return getDeclSpelling(D); 4955 return cxstring::createEmpty(); 4956 } 4957 4958 if (clang_isStatement(C.kind)) { 4959 const Stmt *S = getCursorStmt(C); 4960 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) 4961 return cxstring::createRef(Label->getName()); 4962 4963 return cxstring::createEmpty(); 4964 } 4965 4966 if (C.kind == CXCursor_MacroExpansion) 4967 return cxstring::createRef( 4968 getCursorMacroExpansion(C).getName()->getNameStart()); 4969 4970 if (C.kind == CXCursor_MacroDefinition) 4971 return cxstring::createRef( 4972 getCursorMacroDefinition(C)->getName()->getNameStart()); 4973 4974 if (C.kind == CXCursor_InclusionDirective) 4975 return cxstring::createDup(getCursorInclusionDirective(C)->getFileName()); 4976 4977 if (clang_isDeclaration(C.kind)) 4978 return getDeclSpelling(getCursorDecl(C)); 4979 4980 if (C.kind == CXCursor_AnnotateAttr) { 4981 const AnnotateAttr *AA = cast<AnnotateAttr>(cxcursor::getCursorAttr(C)); 4982 return cxstring::createDup(AA->getAnnotation()); 4983 } 4984 4985 if (C.kind == CXCursor_AsmLabelAttr) { 4986 const AsmLabelAttr *AA = cast<AsmLabelAttr>(cxcursor::getCursorAttr(C)); 4987 return cxstring::createDup(AA->getLabel()); 4988 } 4989 4990 if (C.kind == CXCursor_PackedAttr) { 4991 return cxstring::createRef("packed"); 4992 } 4993 4994 if (C.kind == CXCursor_VisibilityAttr) { 4995 const VisibilityAttr *AA = cast<VisibilityAttr>(cxcursor::getCursorAttr(C)); 4996 switch (AA->getVisibility()) { 4997 case VisibilityAttr::VisibilityType::Default: 4998 return cxstring::createRef("default"); 4999 case VisibilityAttr::VisibilityType::Hidden: 5000 return cxstring::createRef("hidden"); 5001 case VisibilityAttr::VisibilityType::Protected: 5002 return cxstring::createRef("protected"); 5003 } 5004 llvm_unreachable("unknown visibility type"); 5005 } 5006 5007 return cxstring::createEmpty(); 5008} 5009 5010CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C, unsigned pieceIndex, 5011 unsigned options) { 5012 if (clang_Cursor_isNull(C)) 5013 return clang_getNullRange(); 5014 5015 ASTContext &Ctx = getCursorContext(C); 5016 5017 if (clang_isStatement(C.kind)) { 5018 const Stmt *S = getCursorStmt(C); 5019 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) { 5020 if (pieceIndex > 0) 5021 return clang_getNullRange(); 5022 return cxloc::translateSourceRange(Ctx, Label->getIdentLoc()); 5023 } 5024 5025 return clang_getNullRange(); 5026 } 5027 5028 if (C.kind == CXCursor_ObjCMessageExpr) { 5029 if (const ObjCMessageExpr *ME = 5030 dyn_cast_or_null<ObjCMessageExpr>(getCursorExpr(C))) { 5031 if (pieceIndex >= ME->getNumSelectorLocs()) 5032 return clang_getNullRange(); 5033 return cxloc::translateSourceRange(Ctx, ME->getSelectorLoc(pieceIndex)); 5034 } 5035 } 5036 5037 if (C.kind == CXCursor_ObjCInstanceMethodDecl || 5038 C.kind == CXCursor_ObjCClassMethodDecl) { 5039 if (const ObjCMethodDecl *MD = 5040 dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(C))) { 5041 if (pieceIndex >= MD->getNumSelectorLocs()) 5042 return clang_getNullRange(); 5043 return cxloc::translateSourceRange(Ctx, MD->getSelectorLoc(pieceIndex)); 5044 } 5045 } 5046 5047 if (C.kind == CXCursor_ObjCCategoryDecl || 5048 C.kind == CXCursor_ObjCCategoryImplDecl) { 5049 if (pieceIndex > 0) 5050 return clang_getNullRange(); 5051 if (const ObjCCategoryDecl *CD = 5052 dyn_cast_or_null<ObjCCategoryDecl>(getCursorDecl(C))) 5053 return cxloc::translateSourceRange(Ctx, CD->getCategoryNameLoc()); 5054 if (const ObjCCategoryImplDecl *CID = 5055 dyn_cast_or_null<ObjCCategoryImplDecl>(getCursorDecl(C))) 5056 return cxloc::translateSourceRange(Ctx, CID->getCategoryNameLoc()); 5057 } 5058 5059 if (C.kind == CXCursor_ModuleImportDecl) { 5060 if (pieceIndex > 0) 5061 return clang_getNullRange(); 5062 if (const ImportDecl *ImportD = 5063 dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) { 5064 ArrayRef<SourceLocation> Locs = ImportD->getIdentifierLocs(); 5065 if (!Locs.empty()) 5066 return cxloc::translateSourceRange( 5067 Ctx, SourceRange(Locs.front(), Locs.back())); 5068 } 5069 return clang_getNullRange(); 5070 } 5071 5072 if (C.kind == CXCursor_CXXMethod || C.kind == CXCursor_Destructor || 5073 C.kind == CXCursor_ConversionFunction || 5074 C.kind == CXCursor_FunctionDecl) { 5075 if (pieceIndex > 0) 5076 return clang_getNullRange(); 5077 if (const FunctionDecl *FD = 5078 dyn_cast_or_null<FunctionDecl>(getCursorDecl(C))) { 5079 DeclarationNameInfo FunctionName = FD->getNameInfo(); 5080 return cxloc::translateSourceRange(Ctx, FunctionName.getSourceRange()); 5081 } 5082 return clang_getNullRange(); 5083 } 5084 5085 // FIXME: A CXCursor_InclusionDirective should give the location of the 5086 // filename, but we don't keep track of this. 5087 5088 // FIXME: A CXCursor_AnnotateAttr should give the location of the annotation 5089 // but we don't keep track of this. 5090 5091 // FIXME: A CXCursor_AsmLabelAttr should give the location of the label 5092 // but we don't keep track of this. 5093 5094 // Default handling, give the location of the cursor. 5095 5096 if (pieceIndex > 0) 5097 return clang_getNullRange(); 5098 5099 CXSourceLocation CXLoc = clang_getCursorLocation(C); 5100 SourceLocation Loc = cxloc::translateSourceLocation(CXLoc); 5101 return cxloc::translateSourceRange(Ctx, Loc); 5102} 5103 5104CXString clang_Cursor_getMangling(CXCursor C) { 5105 if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind)) 5106 return cxstring::createEmpty(); 5107 5108 // Mangling only works for functions and variables. 5109 const Decl *D = getCursorDecl(C); 5110 if (!D || !(isa<FunctionDecl>(D) || isa<VarDecl>(D))) 5111 return cxstring::createEmpty(); 5112 5113 ASTContext &Ctx = D->getASTContext(); 5114 ASTNameGenerator ASTNameGen(Ctx); 5115 return cxstring::createDup(ASTNameGen.getName(D)); 5116} 5117 5118CXStringSet *clang_Cursor_getCXXManglings(CXCursor C) { 5119 if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind)) 5120 return nullptr; 5121 5122 const Decl *D = getCursorDecl(C); 5123 if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D))) 5124 return nullptr; 5125 5126 ASTContext &Ctx = D->getASTContext(); 5127 ASTNameGenerator ASTNameGen(Ctx); 5128 std::vector<std::string> Manglings = ASTNameGen.getAllManglings(D); 5129 return cxstring::createSet(Manglings); 5130} 5131 5132CXStringSet *clang_Cursor_getObjCManglings(CXCursor C) { 5133 if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind)) 5134 return nullptr; 5135 5136 const Decl *D = getCursorDecl(C); 5137 if (!(isa<ObjCInterfaceDecl>(D) || isa<ObjCImplementationDecl>(D))) 5138 return nullptr; 5139 5140 ASTContext &Ctx = D->getASTContext(); 5141 ASTNameGenerator ASTNameGen(Ctx); 5142 std::vector<std::string> Manglings = ASTNameGen.getAllManglings(D); 5143 return cxstring::createSet(Manglings); 5144} 5145 5146CXPrintingPolicy clang_getCursorPrintingPolicy(CXCursor C) { 5147 if (clang_Cursor_isNull(C)) 5148 return nullptr; 5149 return new PrintingPolicy(getCursorContext(C).getPrintingPolicy()); 5150} 5151 5152void clang_PrintingPolicy_dispose(CXPrintingPolicy Policy) { 5153 if (Policy) 5154 delete static_cast<PrintingPolicy *>(Policy); 5155} 5156 5157unsigned 5158clang_PrintingPolicy_getProperty(CXPrintingPolicy Policy, 5159 enum CXPrintingPolicyProperty Property) { 5160 if (!Policy) 5161 return 0; 5162 5163 PrintingPolicy *P = static_cast<PrintingPolicy *>(Policy); 5164 switch (Property) { 5165 case CXPrintingPolicy_Indentation: 5166 return P->Indentation; 5167 case CXPrintingPolicy_SuppressSpecifiers: 5168 return P->SuppressSpecifiers; 5169 case CXPrintingPolicy_SuppressTagKeyword: 5170 return P->SuppressTagKeyword; 5171 case CXPrintingPolicy_IncludeTagDefinition: 5172 return P->IncludeTagDefinition; 5173 case CXPrintingPolicy_SuppressScope: 5174 return P->SuppressScope; 5175 case CXPrintingPolicy_SuppressUnwrittenScope: 5176 return P->SuppressUnwrittenScope; 5177 case CXPrintingPolicy_SuppressInitializers: 5178 return P->SuppressInitializers; 5179 case CXPrintingPolicy_ConstantArraySizeAsWritten: 5180 return P->ConstantArraySizeAsWritten; 5181 case CXPrintingPolicy_AnonymousTagLocations: 5182 return P->AnonymousTagLocations; 5183 case CXPrintingPolicy_SuppressStrongLifetime: 5184 return P->SuppressStrongLifetime; 5185 case CXPrintingPolicy_SuppressLifetimeQualifiers: 5186 return P->SuppressLifetimeQualifiers; 5187 case CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors: 5188 return P->SuppressTemplateArgsInCXXConstructors; 5189 case CXPrintingPolicy_Bool: 5190 return P->Bool; 5191 case CXPrintingPolicy_Restrict: 5192 return P->Restrict; 5193 case CXPrintingPolicy_Alignof: 5194 return P->Alignof; 5195 case CXPrintingPolicy_UnderscoreAlignof: 5196 return P->UnderscoreAlignof; 5197 case CXPrintingPolicy_UseVoidForZeroParams: 5198 return P->UseVoidForZeroParams; 5199 case CXPrintingPolicy_TerseOutput: 5200 return P->TerseOutput; 5201 case CXPrintingPolicy_PolishForDeclaration: 5202 return P->PolishForDeclaration; 5203 case CXPrintingPolicy_Half: 5204 return P->Half; 5205 case CXPrintingPolicy_MSWChar: 5206 return P->MSWChar; 5207 case CXPrintingPolicy_IncludeNewlines: 5208 return P->IncludeNewlines; 5209 case CXPrintingPolicy_MSVCFormatting: 5210 return P->MSVCFormatting; 5211 case CXPrintingPolicy_ConstantsAsWritten: 5212 return P->ConstantsAsWritten; 5213 case CXPrintingPolicy_SuppressImplicitBase: 5214 return P->SuppressImplicitBase; 5215 case CXPrintingPolicy_FullyQualifiedName: 5216 return P->FullyQualifiedName; 5217 } 5218 5219 assert(false && "Invalid CXPrintingPolicyProperty"); 5220 return 0; 5221} 5222 5223void clang_PrintingPolicy_setProperty(CXPrintingPolicy Policy, 5224 enum CXPrintingPolicyProperty Property, 5225 unsigned Value) { 5226 if (!Policy) 5227 return; 5228 5229 PrintingPolicy *P = static_cast<PrintingPolicy *>(Policy); 5230 switch (Property) { 5231 case CXPrintingPolicy_Indentation: 5232 P->Indentation = Value; 5233 return; 5234 case CXPrintingPolicy_SuppressSpecifiers: 5235 P->SuppressSpecifiers = Value; 5236 return; 5237 case CXPrintingPolicy_SuppressTagKeyword: 5238 P->SuppressTagKeyword = Value; 5239 return; 5240 case CXPrintingPolicy_IncludeTagDefinition: 5241 P->IncludeTagDefinition = Value; 5242 return; 5243 case CXPrintingPolicy_SuppressScope: 5244 P->SuppressScope = Value; 5245 return; 5246 case CXPrintingPolicy_SuppressUnwrittenScope: 5247 P->SuppressUnwrittenScope = Value; 5248 return; 5249 case CXPrintingPolicy_SuppressInitializers: 5250 P->SuppressInitializers = Value; 5251 return; 5252 case CXPrintingPolicy_ConstantArraySizeAsWritten: 5253 P->ConstantArraySizeAsWritten = Value; 5254 return; 5255 case CXPrintingPolicy_AnonymousTagLocations: 5256 P->AnonymousTagLocations = Value; 5257 return; 5258 case CXPrintingPolicy_SuppressStrongLifetime: 5259 P->SuppressStrongLifetime = Value; 5260 return; 5261 case CXPrintingPolicy_SuppressLifetimeQualifiers: 5262 P->SuppressLifetimeQualifiers = Value; 5263 return; 5264 case CXPrintingPolicy_SuppressTemplateArgsInCXXConstructors: 5265 P->SuppressTemplateArgsInCXXConstructors = Value; 5266 return; 5267 case CXPrintingPolicy_Bool: 5268 P->Bool = Value; 5269 return; 5270 case CXPrintingPolicy_Restrict: 5271 P->Restrict = Value; 5272 return; 5273 case CXPrintingPolicy_Alignof: 5274 P->Alignof = Value; 5275 return; 5276 case CXPrintingPolicy_UnderscoreAlignof: 5277 P->UnderscoreAlignof = Value; 5278 return; 5279 case CXPrintingPolicy_UseVoidForZeroParams: 5280 P->UseVoidForZeroParams = Value; 5281 return; 5282 case CXPrintingPolicy_TerseOutput: 5283 P->TerseOutput = Value; 5284 return; 5285 case CXPrintingPolicy_PolishForDeclaration: 5286 P->PolishForDeclaration = Value; 5287 return; 5288 case CXPrintingPolicy_Half: 5289 P->Half = Value; 5290 return; 5291 case CXPrintingPolicy_MSWChar: 5292 P->MSWChar = Value; 5293 return; 5294 case CXPrintingPolicy_IncludeNewlines: 5295 P->IncludeNewlines = Value; 5296 return; 5297 case CXPrintingPolicy_MSVCFormatting: 5298 P->MSVCFormatting = Value; 5299 return; 5300 case CXPrintingPolicy_ConstantsAsWritten: 5301 P->ConstantsAsWritten = Value; 5302 return; 5303 case CXPrintingPolicy_SuppressImplicitBase: 5304 P->SuppressImplicitBase = Value; 5305 return; 5306 case CXPrintingPolicy_FullyQualifiedName: 5307 P->FullyQualifiedName = Value; 5308 return; 5309 } 5310 5311 assert(false && "Invalid CXPrintingPolicyProperty"); 5312} 5313 5314CXString clang_getCursorPrettyPrinted(CXCursor C, CXPrintingPolicy cxPolicy) { 5315 if (clang_Cursor_isNull(C)) 5316 return cxstring::createEmpty(); 5317 5318 if (clang_isDeclaration(C.kind)) { 5319 const Decl *D = getCursorDecl(C); 5320 if (!D) 5321 return cxstring::createEmpty(); 5322 5323 SmallString<128> Str; 5324 llvm::raw_svector_ostream OS(Str); 5325 PrintingPolicy *UserPolicy = static_cast<PrintingPolicy *>(cxPolicy); 5326 D->print(OS, UserPolicy ? *UserPolicy 5327 : getCursorContext(C).getPrintingPolicy()); 5328 5329 return cxstring::createDup(OS.str()); 5330 } 5331 5332 return cxstring::createEmpty(); 5333} 5334 5335CXString clang_getCursorDisplayName(CXCursor C) { 5336 if (!clang_isDeclaration(C.kind)) 5337 return clang_getCursorSpelling(C); 5338 5339 const Decl *D = getCursorDecl(C); 5340 if (!D) 5341 return cxstring::createEmpty(); 5342 5343 PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy(); 5344 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 5345 D = FunTmpl->getTemplatedDecl(); 5346 5347 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 5348 SmallString<64> Str; 5349 llvm::raw_svector_ostream OS(Str); 5350 OS << *Function; 5351 if (Function->getPrimaryTemplate()) 5352 OS << "<>"; 5353 OS << "("; 5354 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) { 5355 if (I) 5356 OS << ", "; 5357 OS << Function->getParamDecl(I)->getType().getAsString(Policy); 5358 } 5359 5360 if (Function->isVariadic()) { 5361 if (Function->getNumParams()) 5362 OS << ", "; 5363 OS << "..."; 5364 } 5365 OS << ")"; 5366 return cxstring::createDup(OS.str()); 5367 } 5368 5369 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) { 5370 SmallString<64> Str; 5371 llvm::raw_svector_ostream OS(Str); 5372 OS << *ClassTemplate; 5373 OS << "<"; 5374 TemplateParameterList *Params = ClassTemplate->getTemplateParameters(); 5375 for (unsigned I = 0, N = Params->size(); I != N; ++I) { 5376 if (I) 5377 OS << ", "; 5378 5379 NamedDecl *Param = Params->getParam(I); 5380 if (Param->getIdentifier()) { 5381 OS << Param->getIdentifier()->getName(); 5382 continue; 5383 } 5384 5385 // There is no parameter name, which makes this tricky. Try to come up 5386 // with something useful that isn't too long. 5387 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 5388 if (const auto *TC = TTP->getTypeConstraint()) { 5389 TC->getConceptNameInfo().printName(OS, Policy); 5390 if (TC->hasExplicitTemplateArgs()) 5391 OS << "<...>"; 5392 } else 5393 OS << (TTP->wasDeclaredWithTypename() ? "typename" : "class"); 5394 else if (NonTypeTemplateParmDecl *NTTP = 5395 dyn_cast<NonTypeTemplateParmDecl>(Param)) 5396 OS << NTTP->getType().getAsString(Policy); 5397 else 5398 OS << "template<...> class"; 5399 } 5400 5401 OS << ">"; 5402 return cxstring::createDup(OS.str()); 5403 } 5404 5405 if (const ClassTemplateSpecializationDecl *ClassSpec = 5406 dyn_cast<ClassTemplateSpecializationDecl>(D)) { 5407 // If the type was explicitly written, use that. 5408 if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten()) 5409 return cxstring::createDup(TSInfo->getType().getAsString(Policy)); 5410 5411 SmallString<128> Str; 5412 llvm::raw_svector_ostream OS(Str); 5413 OS << *ClassSpec; 5414 printTemplateArgumentList( 5415 OS, ClassSpec->getTemplateArgs().asArray(), Policy, 5416 ClassSpec->getSpecializedTemplate()->getTemplateParameters()); 5417 return cxstring::createDup(OS.str()); 5418 } 5419 5420 return clang_getCursorSpelling(C); 5421} 5422 5423CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) { 5424 switch (Kind) { 5425 case CXCursor_FunctionDecl: 5426 return cxstring::createRef("FunctionDecl"); 5427 case CXCursor_TypedefDecl: 5428 return cxstring::createRef("TypedefDecl"); 5429 case CXCursor_EnumDecl: 5430 return cxstring::createRef("EnumDecl"); 5431 case CXCursor_EnumConstantDecl: 5432 return cxstring::createRef("EnumConstantDecl"); 5433 case CXCursor_StructDecl: 5434 return cxstring::createRef("StructDecl"); 5435 case CXCursor_UnionDecl: 5436 return cxstring::createRef("UnionDecl"); 5437 case CXCursor_ClassDecl: 5438 return cxstring::createRef("ClassDecl"); 5439 case CXCursor_FieldDecl: 5440 return cxstring::createRef("FieldDecl"); 5441 case CXCursor_VarDecl: 5442 return cxstring::createRef("VarDecl"); 5443 case CXCursor_ParmDecl: 5444 return cxstring::createRef("ParmDecl"); 5445 case CXCursor_ObjCInterfaceDecl: 5446 return cxstring::createRef("ObjCInterfaceDecl"); 5447 case CXCursor_ObjCCategoryDecl: 5448 return cxstring::createRef("ObjCCategoryDecl"); 5449 case CXCursor_ObjCProtocolDecl: 5450 return cxstring::createRef("ObjCProtocolDecl"); 5451 case CXCursor_ObjCPropertyDecl: 5452 return cxstring::createRef("ObjCPropertyDecl"); 5453 case CXCursor_ObjCIvarDecl: 5454 return cxstring::createRef("ObjCIvarDecl"); 5455 case CXCursor_ObjCInstanceMethodDecl: 5456 return cxstring::createRef("ObjCInstanceMethodDecl"); 5457 case CXCursor_ObjCClassMethodDecl: 5458 return cxstring::createRef("ObjCClassMethodDecl"); 5459 case CXCursor_ObjCImplementationDecl: 5460 return cxstring::createRef("ObjCImplementationDecl"); 5461 case CXCursor_ObjCCategoryImplDecl: 5462 return cxstring::createRef("ObjCCategoryImplDecl"); 5463 case CXCursor_CXXMethod: 5464 return cxstring::createRef("CXXMethod"); 5465 case CXCursor_UnexposedDecl: 5466 return cxstring::createRef("UnexposedDecl"); 5467 case CXCursor_ObjCSuperClassRef: 5468 return cxstring::createRef("ObjCSuperClassRef"); 5469 case CXCursor_ObjCProtocolRef: 5470 return cxstring::createRef("ObjCProtocolRef"); 5471 case CXCursor_ObjCClassRef: 5472 return cxstring::createRef("ObjCClassRef"); 5473 case CXCursor_TypeRef: 5474 return cxstring::createRef("TypeRef"); 5475 case CXCursor_TemplateRef: 5476 return cxstring::createRef("TemplateRef"); 5477 case CXCursor_NamespaceRef: 5478 return cxstring::createRef("NamespaceRef"); 5479 case CXCursor_MemberRef: 5480 return cxstring::createRef("MemberRef"); 5481 case CXCursor_LabelRef: 5482 return cxstring::createRef("LabelRef"); 5483 case CXCursor_OverloadedDeclRef: 5484 return cxstring::createRef("OverloadedDeclRef"); 5485 case CXCursor_VariableRef: 5486 return cxstring::createRef("VariableRef"); 5487 case CXCursor_IntegerLiteral: 5488 return cxstring::createRef("IntegerLiteral"); 5489 case CXCursor_FixedPointLiteral: 5490 return cxstring::createRef("FixedPointLiteral"); 5491 case CXCursor_FloatingLiteral: 5492 return cxstring::createRef("FloatingLiteral"); 5493 case CXCursor_ImaginaryLiteral: 5494 return cxstring::createRef("ImaginaryLiteral"); 5495 case CXCursor_StringLiteral: 5496 return cxstring::createRef("StringLiteral"); 5497 case CXCursor_CharacterLiteral: 5498 return cxstring::createRef("CharacterLiteral"); 5499 case CXCursor_ParenExpr: 5500 return cxstring::createRef("ParenExpr"); 5501 case CXCursor_UnaryOperator: 5502 return cxstring::createRef("UnaryOperator"); 5503 case CXCursor_ArraySubscriptExpr: 5504 return cxstring::createRef("ArraySubscriptExpr"); 5505 case CXCursor_OMPArraySectionExpr: 5506 return cxstring::createRef("OMPArraySectionExpr"); 5507 case CXCursor_OMPArrayShapingExpr: 5508 return cxstring::createRef("OMPArrayShapingExpr"); 5509 case CXCursor_OMPIteratorExpr: 5510 return cxstring::createRef("OMPIteratorExpr"); 5511 case CXCursor_BinaryOperator: 5512 return cxstring::createRef("BinaryOperator"); 5513 case CXCursor_CompoundAssignOperator: 5514 return cxstring::createRef("CompoundAssignOperator"); 5515 case CXCursor_ConditionalOperator: 5516 return cxstring::createRef("ConditionalOperator"); 5517 case CXCursor_CStyleCastExpr: 5518 return cxstring::createRef("CStyleCastExpr"); 5519 case CXCursor_CompoundLiteralExpr: 5520 return cxstring::createRef("CompoundLiteralExpr"); 5521 case CXCursor_InitListExpr: 5522 return cxstring::createRef("InitListExpr"); 5523 case CXCursor_AddrLabelExpr: 5524 return cxstring::createRef("AddrLabelExpr"); 5525 case CXCursor_StmtExpr: 5526 return cxstring::createRef("StmtExpr"); 5527 case CXCursor_GenericSelectionExpr: 5528 return cxstring::createRef("GenericSelectionExpr"); 5529 case CXCursor_GNUNullExpr: 5530 return cxstring::createRef("GNUNullExpr"); 5531 case CXCursor_CXXStaticCastExpr: 5532 return cxstring::createRef("CXXStaticCastExpr"); 5533 case CXCursor_CXXDynamicCastExpr: 5534 return cxstring::createRef("CXXDynamicCastExpr"); 5535 case CXCursor_CXXReinterpretCastExpr: 5536 return cxstring::createRef("CXXReinterpretCastExpr"); 5537 case CXCursor_CXXConstCastExpr: 5538 return cxstring::createRef("CXXConstCastExpr"); 5539 case CXCursor_CXXFunctionalCastExpr: 5540 return cxstring::createRef("CXXFunctionalCastExpr"); 5541 case CXCursor_CXXAddrspaceCastExpr: 5542 return cxstring::createRef("CXXAddrspaceCastExpr"); 5543 case CXCursor_CXXTypeidExpr: 5544 return cxstring::createRef("CXXTypeidExpr"); 5545 case CXCursor_CXXBoolLiteralExpr: 5546 return cxstring::createRef("CXXBoolLiteralExpr"); 5547 case CXCursor_CXXNullPtrLiteralExpr: 5548 return cxstring::createRef("CXXNullPtrLiteralExpr"); 5549 case CXCursor_CXXThisExpr: 5550 return cxstring::createRef("CXXThisExpr"); 5551 case CXCursor_CXXThrowExpr: 5552 return cxstring::createRef("CXXThrowExpr"); 5553 case CXCursor_CXXNewExpr: 5554 return cxstring::createRef("CXXNewExpr"); 5555 case CXCursor_CXXDeleteExpr: 5556 return cxstring::createRef("CXXDeleteExpr"); 5557 case CXCursor_UnaryExpr: 5558 return cxstring::createRef("UnaryExpr"); 5559 case CXCursor_ObjCStringLiteral: 5560 return cxstring::createRef("ObjCStringLiteral"); 5561 case CXCursor_ObjCBoolLiteralExpr: 5562 return cxstring::createRef("ObjCBoolLiteralExpr"); 5563 case CXCursor_ObjCAvailabilityCheckExpr: 5564 return cxstring::createRef("ObjCAvailabilityCheckExpr"); 5565 case CXCursor_ObjCSelfExpr: 5566 return cxstring::createRef("ObjCSelfExpr"); 5567 case CXCursor_ObjCEncodeExpr: 5568 return cxstring::createRef("ObjCEncodeExpr"); 5569 case CXCursor_ObjCSelectorExpr: 5570 return cxstring::createRef("ObjCSelectorExpr"); 5571 case CXCursor_ObjCProtocolExpr: 5572 return cxstring::createRef("ObjCProtocolExpr"); 5573 case CXCursor_ObjCBridgedCastExpr: 5574 return cxstring::createRef("ObjCBridgedCastExpr"); 5575 case CXCursor_BlockExpr: 5576 return cxstring::createRef("BlockExpr"); 5577 case CXCursor_PackExpansionExpr: 5578 return cxstring::createRef("PackExpansionExpr"); 5579 case CXCursor_SizeOfPackExpr: 5580 return cxstring::createRef("SizeOfPackExpr"); 5581 case CXCursor_LambdaExpr: 5582 return cxstring::createRef("LambdaExpr"); 5583 case CXCursor_UnexposedExpr: 5584 return cxstring::createRef("UnexposedExpr"); 5585 case CXCursor_DeclRefExpr: 5586 return cxstring::createRef("DeclRefExpr"); 5587 case CXCursor_MemberRefExpr: 5588 return cxstring::createRef("MemberRefExpr"); 5589 case CXCursor_CallExpr: 5590 return cxstring::createRef("CallExpr"); 5591 case CXCursor_ObjCMessageExpr: 5592 return cxstring::createRef("ObjCMessageExpr"); 5593 case CXCursor_BuiltinBitCastExpr: 5594 return cxstring::createRef("BuiltinBitCastExpr"); 5595 case CXCursor_ConceptSpecializationExpr: 5596 return cxstring::createRef("ConceptSpecializationExpr"); 5597 case CXCursor_RequiresExpr: 5598 return cxstring::createRef("RequiresExpr"); 5599 case CXCursor_CXXParenListInitExpr: 5600 return cxstring::createRef("CXXParenListInitExpr"); 5601 case CXCursor_UnexposedStmt: 5602 return cxstring::createRef("UnexposedStmt"); 5603 case CXCursor_DeclStmt: 5604 return cxstring::createRef("DeclStmt"); 5605 case CXCursor_LabelStmt: 5606 return cxstring::createRef("LabelStmt"); 5607 case CXCursor_CompoundStmt: 5608 return cxstring::createRef("CompoundStmt"); 5609 case CXCursor_CaseStmt: 5610 return cxstring::createRef("CaseStmt"); 5611 case CXCursor_DefaultStmt: 5612 return cxstring::createRef("DefaultStmt"); 5613 case CXCursor_IfStmt: 5614 return cxstring::createRef("IfStmt"); 5615 case CXCursor_SwitchStmt: 5616 return cxstring::createRef("SwitchStmt"); 5617 case CXCursor_WhileStmt: 5618 return cxstring::createRef("WhileStmt"); 5619 case CXCursor_DoStmt: 5620 return cxstring::createRef("DoStmt"); 5621 case CXCursor_ForStmt: 5622 return cxstring::createRef("ForStmt"); 5623 case CXCursor_GotoStmt: 5624 return cxstring::createRef("GotoStmt"); 5625 case CXCursor_IndirectGotoStmt: 5626 return cxstring::createRef("IndirectGotoStmt"); 5627 case CXCursor_ContinueStmt: 5628 return cxstring::createRef("ContinueStmt"); 5629 case CXCursor_BreakStmt: 5630 return cxstring::createRef("BreakStmt"); 5631 case CXCursor_ReturnStmt: 5632 return cxstring::createRef("ReturnStmt"); 5633 case CXCursor_GCCAsmStmt: 5634 return cxstring::createRef("GCCAsmStmt"); 5635 case CXCursor_MSAsmStmt: 5636 return cxstring::createRef("MSAsmStmt"); 5637 case CXCursor_ObjCAtTryStmt: 5638 return cxstring::createRef("ObjCAtTryStmt"); 5639 case CXCursor_ObjCAtCatchStmt: 5640 return cxstring::createRef("ObjCAtCatchStmt"); 5641 case CXCursor_ObjCAtFinallyStmt: 5642 return cxstring::createRef("ObjCAtFinallyStmt"); 5643 case CXCursor_ObjCAtThrowStmt: 5644 return cxstring::createRef("ObjCAtThrowStmt"); 5645 case CXCursor_ObjCAtSynchronizedStmt: 5646 return cxstring::createRef("ObjCAtSynchronizedStmt"); 5647 case CXCursor_ObjCAutoreleasePoolStmt: 5648 return cxstring::createRef("ObjCAutoreleasePoolStmt"); 5649 case CXCursor_ObjCForCollectionStmt: 5650 return cxstring::createRef("ObjCForCollectionStmt"); 5651 case CXCursor_CXXCatchStmt: 5652 return cxstring::createRef("CXXCatchStmt"); 5653 case CXCursor_CXXTryStmt: 5654 return cxstring::createRef("CXXTryStmt"); 5655 case CXCursor_CXXForRangeStmt: 5656 return cxstring::createRef("CXXForRangeStmt"); 5657 case CXCursor_SEHTryStmt: 5658 return cxstring::createRef("SEHTryStmt"); 5659 case CXCursor_SEHExceptStmt: 5660 return cxstring::createRef("SEHExceptStmt"); 5661 case CXCursor_SEHFinallyStmt: 5662 return cxstring::createRef("SEHFinallyStmt"); 5663 case CXCursor_SEHLeaveStmt: 5664 return cxstring::createRef("SEHLeaveStmt"); 5665 case CXCursor_NullStmt: 5666 return cxstring::createRef("NullStmt"); 5667 case CXCursor_InvalidFile: 5668 return cxstring::createRef("InvalidFile"); 5669 case CXCursor_InvalidCode: 5670 return cxstring::createRef("InvalidCode"); 5671 case CXCursor_NoDeclFound: 5672 return cxstring::createRef("NoDeclFound"); 5673 case CXCursor_NotImplemented: 5674 return cxstring::createRef("NotImplemented"); 5675 case CXCursor_TranslationUnit: 5676 return cxstring::createRef("TranslationUnit"); 5677 case CXCursor_UnexposedAttr: 5678 return cxstring::createRef("UnexposedAttr"); 5679 case CXCursor_IBActionAttr: 5680 return cxstring::createRef("attribute(ibaction)"); 5681 case CXCursor_IBOutletAttr: 5682 return cxstring::createRef("attribute(iboutlet)"); 5683 case CXCursor_IBOutletCollectionAttr: 5684 return cxstring::createRef("attribute(iboutletcollection)"); 5685 case CXCursor_CXXFinalAttr: 5686 return cxstring::createRef("attribute(final)"); 5687 case CXCursor_CXXOverrideAttr: 5688 return cxstring::createRef("attribute(override)"); 5689 case CXCursor_AnnotateAttr: 5690 return cxstring::createRef("attribute(annotate)"); 5691 case CXCursor_AsmLabelAttr: 5692 return cxstring::createRef("asm label"); 5693 case CXCursor_PackedAttr: 5694 return cxstring::createRef("attribute(packed)"); 5695 case CXCursor_PureAttr: 5696 return cxstring::createRef("attribute(pure)"); 5697 case CXCursor_ConstAttr: 5698 return cxstring::createRef("attribute(const)"); 5699 case CXCursor_NoDuplicateAttr: 5700 return cxstring::createRef("attribute(noduplicate)"); 5701 case CXCursor_CUDAConstantAttr: 5702 return cxstring::createRef("attribute(constant)"); 5703 case CXCursor_CUDADeviceAttr: 5704 return cxstring::createRef("attribute(device)"); 5705 case CXCursor_CUDAGlobalAttr: 5706 return cxstring::createRef("attribute(global)"); 5707 case CXCursor_CUDAHostAttr: 5708 return cxstring::createRef("attribute(host)"); 5709 case CXCursor_CUDASharedAttr: 5710 return cxstring::createRef("attribute(shared)"); 5711 case CXCursor_VisibilityAttr: 5712 return cxstring::createRef("attribute(visibility)"); 5713 case CXCursor_DLLExport: 5714 return cxstring::createRef("attribute(dllexport)"); 5715 case CXCursor_DLLImport: 5716 return cxstring::createRef("attribute(dllimport)"); 5717 case CXCursor_NSReturnsRetained: 5718 return cxstring::createRef("attribute(ns_returns_retained)"); 5719 case CXCursor_NSReturnsNotRetained: 5720 return cxstring::createRef("attribute(ns_returns_not_retained)"); 5721 case CXCursor_NSReturnsAutoreleased: 5722 return cxstring::createRef("attribute(ns_returns_autoreleased)"); 5723 case CXCursor_NSConsumesSelf: 5724 return cxstring::createRef("attribute(ns_consumes_self)"); 5725 case CXCursor_NSConsumed: 5726 return cxstring::createRef("attribute(ns_consumed)"); 5727 case CXCursor_ObjCException: 5728 return cxstring::createRef("attribute(objc_exception)"); 5729 case CXCursor_ObjCNSObject: 5730 return cxstring::createRef("attribute(NSObject)"); 5731 case CXCursor_ObjCIndependentClass: 5732 return cxstring::createRef("attribute(objc_independent_class)"); 5733 case CXCursor_ObjCPreciseLifetime: 5734 return cxstring::createRef("attribute(objc_precise_lifetime)"); 5735 case CXCursor_ObjCReturnsInnerPointer: 5736 return cxstring::createRef("attribute(objc_returns_inner_pointer)"); 5737 case CXCursor_ObjCRequiresSuper: 5738 return cxstring::createRef("attribute(objc_requires_super)"); 5739 case CXCursor_ObjCRootClass: 5740 return cxstring::createRef("attribute(objc_root_class)"); 5741 case CXCursor_ObjCSubclassingRestricted: 5742 return cxstring::createRef("attribute(objc_subclassing_restricted)"); 5743 case CXCursor_ObjCExplicitProtocolImpl: 5744 return cxstring::createRef( 5745 "attribute(objc_protocol_requires_explicit_implementation)"); 5746 case CXCursor_ObjCDesignatedInitializer: 5747 return cxstring::createRef("attribute(objc_designated_initializer)"); 5748 case CXCursor_ObjCRuntimeVisible: 5749 return cxstring::createRef("attribute(objc_runtime_visible)"); 5750 case CXCursor_ObjCBoxable: 5751 return cxstring::createRef("attribute(objc_boxable)"); 5752 case CXCursor_FlagEnum: 5753 return cxstring::createRef("attribute(flag_enum)"); 5754 case CXCursor_PreprocessingDirective: 5755 return cxstring::createRef("preprocessing directive"); 5756 case CXCursor_MacroDefinition: 5757 return cxstring::createRef("macro definition"); 5758 case CXCursor_MacroExpansion: 5759 return cxstring::createRef("macro expansion"); 5760 case CXCursor_InclusionDirective: 5761 return cxstring::createRef("inclusion directive"); 5762 case CXCursor_Namespace: 5763 return cxstring::createRef("Namespace"); 5764 case CXCursor_LinkageSpec: 5765 return cxstring::createRef("LinkageSpec"); 5766 case CXCursor_CXXBaseSpecifier: 5767 return cxstring::createRef("C++ base class specifier"); 5768 case CXCursor_Constructor: 5769 return cxstring::createRef("CXXConstructor"); 5770 case CXCursor_Destructor: 5771 return cxstring::createRef("CXXDestructor"); 5772 case CXCursor_ConversionFunction: 5773 return cxstring::createRef("CXXConversion"); 5774 case CXCursor_TemplateTypeParameter: 5775 return cxstring::createRef("TemplateTypeParameter"); 5776 case CXCursor_NonTypeTemplateParameter: 5777 return cxstring::createRef("NonTypeTemplateParameter"); 5778 case CXCursor_TemplateTemplateParameter: 5779 return cxstring::createRef("TemplateTemplateParameter"); 5780 case CXCursor_FunctionTemplate: 5781 return cxstring::createRef("FunctionTemplate"); 5782 case CXCursor_ClassTemplate: 5783 return cxstring::createRef("ClassTemplate"); 5784 case CXCursor_ClassTemplatePartialSpecialization: 5785 return cxstring::createRef("ClassTemplatePartialSpecialization"); 5786 case CXCursor_NamespaceAlias: 5787 return cxstring::createRef("NamespaceAlias"); 5788 case CXCursor_UsingDirective: 5789 return cxstring::createRef("UsingDirective"); 5790 case CXCursor_UsingDeclaration: 5791 return cxstring::createRef("UsingDeclaration"); 5792 case CXCursor_TypeAliasDecl: 5793 return cxstring::createRef("TypeAliasDecl"); 5794 case CXCursor_ObjCSynthesizeDecl: 5795 return cxstring::createRef("ObjCSynthesizeDecl"); 5796 case CXCursor_ObjCDynamicDecl: 5797 return cxstring::createRef("ObjCDynamicDecl"); 5798 case CXCursor_CXXAccessSpecifier: 5799 return cxstring::createRef("CXXAccessSpecifier"); 5800 case CXCursor_ModuleImportDecl: 5801 return cxstring::createRef("ModuleImport"); 5802 case CXCursor_OMPCanonicalLoop: 5803 return cxstring::createRef("OMPCanonicalLoop"); 5804 case CXCursor_OMPMetaDirective: 5805 return cxstring::createRef("OMPMetaDirective"); 5806 case CXCursor_OMPParallelDirective: 5807 return cxstring::createRef("OMPParallelDirective"); 5808 case CXCursor_OMPSimdDirective: 5809 return cxstring::createRef("OMPSimdDirective"); 5810 case CXCursor_OMPTileDirective: 5811 return cxstring::createRef("OMPTileDirective"); 5812 case CXCursor_OMPUnrollDirective: 5813 return cxstring::createRef("OMPUnrollDirective"); 5814 case CXCursor_OMPForDirective: 5815 return cxstring::createRef("OMPForDirective"); 5816 case CXCursor_OMPForSimdDirective: 5817 return cxstring::createRef("OMPForSimdDirective"); 5818 case CXCursor_OMPSectionsDirective: 5819 return cxstring::createRef("OMPSectionsDirective"); 5820 case CXCursor_OMPSectionDirective: 5821 return cxstring::createRef("OMPSectionDirective"); 5822 case CXCursor_OMPSingleDirective: 5823 return cxstring::createRef("OMPSingleDirective"); 5824 case CXCursor_OMPMasterDirective: 5825 return cxstring::createRef("OMPMasterDirective"); 5826 case CXCursor_OMPCriticalDirective: 5827 return cxstring::createRef("OMPCriticalDirective"); 5828 case CXCursor_OMPParallelForDirective: 5829 return cxstring::createRef("OMPParallelForDirective"); 5830 case CXCursor_OMPParallelForSimdDirective: 5831 return cxstring::createRef("OMPParallelForSimdDirective"); 5832 case CXCursor_OMPParallelMasterDirective: 5833 return cxstring::createRef("OMPParallelMasterDirective"); 5834 case CXCursor_OMPParallelMaskedDirective: 5835 return cxstring::createRef("OMPParallelMaskedDirective"); 5836 case CXCursor_OMPParallelSectionsDirective: 5837 return cxstring::createRef("OMPParallelSectionsDirective"); 5838 case CXCursor_OMPTaskDirective: 5839 return cxstring::createRef("OMPTaskDirective"); 5840 case CXCursor_OMPTaskyieldDirective: 5841 return cxstring::createRef("OMPTaskyieldDirective"); 5842 case CXCursor_OMPBarrierDirective: 5843 return cxstring::createRef("OMPBarrierDirective"); 5844 case CXCursor_OMPTaskwaitDirective: 5845 return cxstring::createRef("OMPTaskwaitDirective"); 5846 case CXCursor_OMPErrorDirective: 5847 return cxstring::createRef("OMPErrorDirective"); 5848 case CXCursor_OMPTaskgroupDirective: 5849 return cxstring::createRef("OMPTaskgroupDirective"); 5850 case CXCursor_OMPFlushDirective: 5851 return cxstring::createRef("OMPFlushDirective"); 5852 case CXCursor_OMPDepobjDirective: 5853 return cxstring::createRef("OMPDepobjDirective"); 5854 case CXCursor_OMPScanDirective: 5855 return cxstring::createRef("OMPScanDirective"); 5856 case CXCursor_OMPOrderedDirective: 5857 return cxstring::createRef("OMPOrderedDirective"); 5858 case CXCursor_OMPAtomicDirective: 5859 return cxstring::createRef("OMPAtomicDirective"); 5860 case CXCursor_OMPTargetDirective: 5861 return cxstring::createRef("OMPTargetDirective"); 5862 case CXCursor_OMPTargetDataDirective: 5863 return cxstring::createRef("OMPTargetDataDirective"); 5864 case CXCursor_OMPTargetEnterDataDirective: 5865 return cxstring::createRef("OMPTargetEnterDataDirective"); 5866 case CXCursor_OMPTargetExitDataDirective: 5867 return cxstring::createRef("OMPTargetExitDataDirective"); 5868 case CXCursor_OMPTargetParallelDirective: 5869 return cxstring::createRef("OMPTargetParallelDirective"); 5870 case CXCursor_OMPTargetParallelForDirective: 5871 return cxstring::createRef("OMPTargetParallelForDirective"); 5872 case CXCursor_OMPTargetUpdateDirective: 5873 return cxstring::createRef("OMPTargetUpdateDirective"); 5874 case CXCursor_OMPTeamsDirective: 5875 return cxstring::createRef("OMPTeamsDirective"); 5876 case CXCursor_OMPCancellationPointDirective: 5877 return cxstring::createRef("OMPCancellationPointDirective"); 5878 case CXCursor_OMPCancelDirective: 5879 return cxstring::createRef("OMPCancelDirective"); 5880 case CXCursor_OMPTaskLoopDirective: 5881 return cxstring::createRef("OMPTaskLoopDirective"); 5882 case CXCursor_OMPTaskLoopSimdDirective: 5883 return cxstring::createRef("OMPTaskLoopSimdDirective"); 5884 case CXCursor_OMPMasterTaskLoopDirective: 5885 return cxstring::createRef("OMPMasterTaskLoopDirective"); 5886 case CXCursor_OMPMaskedTaskLoopDirective: 5887 return cxstring::createRef("OMPMaskedTaskLoopDirective"); 5888 case CXCursor_OMPMasterTaskLoopSimdDirective: 5889 return cxstring::createRef("OMPMasterTaskLoopSimdDirective"); 5890 case CXCursor_OMPMaskedTaskLoopSimdDirective: 5891 return cxstring::createRef("OMPMaskedTaskLoopSimdDirective"); 5892 case CXCursor_OMPParallelMasterTaskLoopDirective: 5893 return cxstring::createRef("OMPParallelMasterTaskLoopDirective"); 5894 case CXCursor_OMPParallelMaskedTaskLoopDirective: 5895 return cxstring::createRef("OMPParallelMaskedTaskLoopDirective"); 5896 case CXCursor_OMPParallelMasterTaskLoopSimdDirective: 5897 return cxstring::createRef("OMPParallelMasterTaskLoopSimdDirective"); 5898 case CXCursor_OMPParallelMaskedTaskLoopSimdDirective: 5899 return cxstring::createRef("OMPParallelMaskedTaskLoopSimdDirective"); 5900 case CXCursor_OMPDistributeDirective: 5901 return cxstring::createRef("OMPDistributeDirective"); 5902 case CXCursor_OMPDistributeParallelForDirective: 5903 return cxstring::createRef("OMPDistributeParallelForDirective"); 5904 case CXCursor_OMPDistributeParallelForSimdDirective: 5905 return cxstring::createRef("OMPDistributeParallelForSimdDirective"); 5906 case CXCursor_OMPDistributeSimdDirective: 5907 return cxstring::createRef("OMPDistributeSimdDirective"); 5908 case CXCursor_OMPTargetParallelForSimdDirective: 5909 return cxstring::createRef("OMPTargetParallelForSimdDirective"); 5910 case CXCursor_OMPTargetSimdDirective: 5911 return cxstring::createRef("OMPTargetSimdDirective"); 5912 case CXCursor_OMPTeamsDistributeDirective: 5913 return cxstring::createRef("OMPTeamsDistributeDirective"); 5914 case CXCursor_OMPTeamsDistributeSimdDirective: 5915 return cxstring::createRef("OMPTeamsDistributeSimdDirective"); 5916 case CXCursor_OMPTeamsDistributeParallelForSimdDirective: 5917 return cxstring::createRef("OMPTeamsDistributeParallelForSimdDirective"); 5918 case CXCursor_OMPTeamsDistributeParallelForDirective: 5919 return cxstring::createRef("OMPTeamsDistributeParallelForDirective"); 5920 case CXCursor_OMPTargetTeamsDirective: 5921 return cxstring::createRef("OMPTargetTeamsDirective"); 5922 case CXCursor_OMPTargetTeamsDistributeDirective: 5923 return cxstring::createRef("OMPTargetTeamsDistributeDirective"); 5924 case CXCursor_OMPTargetTeamsDistributeParallelForDirective: 5925 return cxstring::createRef("OMPTargetTeamsDistributeParallelForDirective"); 5926 case CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective: 5927 return cxstring::createRef( 5928 "OMPTargetTeamsDistributeParallelForSimdDirective"); 5929 case CXCursor_OMPTargetTeamsDistributeSimdDirective: 5930 return cxstring::createRef("OMPTargetTeamsDistributeSimdDirective"); 5931 case CXCursor_OMPInteropDirective: 5932 return cxstring::createRef("OMPInteropDirective"); 5933 case CXCursor_OMPDispatchDirective: 5934 return cxstring::createRef("OMPDispatchDirective"); 5935 case CXCursor_OMPMaskedDirective: 5936 return cxstring::createRef("OMPMaskedDirective"); 5937 case CXCursor_OMPGenericLoopDirective: 5938 return cxstring::createRef("OMPGenericLoopDirective"); 5939 case CXCursor_OMPTeamsGenericLoopDirective: 5940 return cxstring::createRef("OMPTeamsGenericLoopDirective"); 5941 case CXCursor_OMPTargetTeamsGenericLoopDirective: 5942 return cxstring::createRef("OMPTargetTeamsGenericLoopDirective"); 5943 case CXCursor_OMPParallelGenericLoopDirective: 5944 return cxstring::createRef("OMPParallelGenericLoopDirective"); 5945 case CXCursor_OMPTargetParallelGenericLoopDirective: 5946 return cxstring::createRef("OMPTargetParallelGenericLoopDirective"); 5947 case CXCursor_OverloadCandidate: 5948 return cxstring::createRef("OverloadCandidate"); 5949 case CXCursor_TypeAliasTemplateDecl: 5950 return cxstring::createRef("TypeAliasTemplateDecl"); 5951 case CXCursor_StaticAssert: 5952 return cxstring::createRef("StaticAssert"); 5953 case CXCursor_FriendDecl: 5954 return cxstring::createRef("FriendDecl"); 5955 case CXCursor_ConvergentAttr: 5956 return cxstring::createRef("attribute(convergent)"); 5957 case CXCursor_WarnUnusedAttr: 5958 return cxstring::createRef("attribute(warn_unused)"); 5959 case CXCursor_WarnUnusedResultAttr: 5960 return cxstring::createRef("attribute(warn_unused_result)"); 5961 case CXCursor_AlignedAttr: 5962 return cxstring::createRef("attribute(aligned)"); 5963 case CXCursor_ConceptDecl: 5964 return cxstring::createRef("ConceptDecl"); 5965 } 5966 5967 llvm_unreachable("Unhandled CXCursorKind"); 5968} 5969 5970struct GetCursorData { 5971 SourceLocation TokenBeginLoc; 5972 bool PointsAtMacroArgExpansion; 5973 bool VisitedObjCPropertyImplDecl; 5974 SourceLocation VisitedDeclaratorDeclStartLoc; 5975 CXCursor &BestCursor; 5976 5977 GetCursorData(SourceManager &SM, SourceLocation tokenBegin, 5978 CXCursor &outputCursor) 5979 : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) { 5980 PointsAtMacroArgExpansion = SM.isMacroArgExpansion(tokenBegin); 5981 VisitedObjCPropertyImplDecl = false; 5982 } 5983}; 5984 5985static enum CXChildVisitResult 5986GetCursorVisitor(CXCursor cursor, CXCursor parent, CXClientData client_data) { 5987 GetCursorData *Data = static_cast<GetCursorData *>(client_data); 5988 CXCursor *BestCursor = &Data->BestCursor; 5989 5990 // If we point inside a macro argument we should provide info of what the 5991 // token is so use the actual cursor, don't replace it with a macro expansion 5992 // cursor. 5993 if (cursor.kind == CXCursor_MacroExpansion && Data->PointsAtMacroArgExpansion) 5994 return CXChildVisit_Recurse; 5995 5996 if (clang_isDeclaration(cursor.kind)) { 5997 // Avoid having the implicit methods override the property decls. 5998 if (const ObjCMethodDecl *MD = 5999 dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) { 6000 if (MD->isImplicit()) 6001 return CXChildVisit_Break; 6002 6003 } else if (const ObjCInterfaceDecl *ID = 6004 dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(cursor))) { 6005 // Check that when we have multiple @class references in the same line, 6006 // that later ones do not override the previous ones. 6007 // If we have: 6008 // @class Foo, Bar; 6009 // source ranges for both start at '@', so 'Bar' will end up overriding 6010 // 'Foo' even though the cursor location was at 'Foo'. 6011 if (BestCursor->kind == CXCursor_ObjCInterfaceDecl || 6012 BestCursor->kind == CXCursor_ObjCClassRef) 6013 if (const ObjCInterfaceDecl *PrevID = 6014 dyn_cast_or_null<ObjCInterfaceDecl>( 6015 getCursorDecl(*BestCursor))) { 6016 if (PrevID != ID && !PrevID->isThisDeclarationADefinition() && 6017 !ID->isThisDeclarationADefinition()) 6018 return CXChildVisit_Break; 6019 } 6020 6021 } else if (const DeclaratorDecl *DD = 6022 dyn_cast_or_null<DeclaratorDecl>(getCursorDecl(cursor))) { 6023 SourceLocation StartLoc = DD->getSourceRange().getBegin(); 6024 // Check that when we have multiple declarators in the same line, 6025 // that later ones do not override the previous ones. 6026 // If we have: 6027 // int Foo, Bar; 6028 // source ranges for both start at 'int', so 'Bar' will end up overriding 6029 // 'Foo' even though the cursor location was at 'Foo'. 6030 if (Data->VisitedDeclaratorDeclStartLoc == StartLoc) 6031 return CXChildVisit_Break; 6032 Data->VisitedDeclaratorDeclStartLoc = StartLoc; 6033 6034 } else if (const ObjCPropertyImplDecl *PropImp = 6035 dyn_cast_or_null<ObjCPropertyImplDecl>( 6036 getCursorDecl(cursor))) { 6037 (void)PropImp; 6038 // Check that when we have multiple @synthesize in the same line, 6039 // that later ones do not override the previous ones. 6040 // If we have: 6041 // @synthesize Foo, Bar; 6042 // source ranges for both start at '@', so 'Bar' will end up overriding 6043 // 'Foo' even though the cursor location was at 'Foo'. 6044 if (Data->VisitedObjCPropertyImplDecl) 6045 return CXChildVisit_Break; 6046 Data->VisitedObjCPropertyImplDecl = true; 6047 } 6048 } 6049 6050 if (clang_isExpression(cursor.kind) && 6051 clang_isDeclaration(BestCursor->kind)) { 6052 if (const Decl *D = getCursorDecl(*BestCursor)) { 6053 // Avoid having the cursor of an expression replace the declaration cursor 6054 // when the expression source range overlaps the declaration range. 6055 // This can happen for C++ constructor expressions whose range generally 6056 // include the variable declaration, e.g.: 6057 // MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl 6058 // cursor. 6059 if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() && 6060 D->getLocation() == Data->TokenBeginLoc) 6061 return CXChildVisit_Break; 6062 } 6063 } 6064 6065 // If our current best cursor is the construction of a temporary object, 6066 // don't replace that cursor with a type reference, because we want 6067 // clang_getCursor() to point at the constructor. 6068 if (clang_isExpression(BestCursor->kind) && 6069 isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) && 6070 cursor.kind == CXCursor_TypeRef) { 6071 // Keep the cursor pointing at CXXTemporaryObjectExpr but also mark it 6072 // as having the actual point on the type reference. 6073 *BestCursor = getTypeRefedCallExprCursor(*BestCursor); 6074 return CXChildVisit_Recurse; 6075 } 6076 6077 // If we already have an Objective-C superclass reference, don't 6078 // update it further. 6079 if (BestCursor->kind == CXCursor_ObjCSuperClassRef) 6080 return CXChildVisit_Break; 6081 6082 *BestCursor = cursor; 6083 return CXChildVisit_Recurse; 6084} 6085 6086CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) { 6087 if (isNotUsableTU(TU)) { 6088 LOG_BAD_TU(TU); 6089 return clang_getNullCursor(); 6090 } 6091 6092 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 6093 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 6094 6095 SourceLocation SLoc = cxloc::translateSourceLocation(Loc); 6096 CXCursor Result = cxcursor::getCursor(TU, SLoc); 6097 6098 LOG_FUNC_SECTION { 6099 CXFile SearchFile; 6100 unsigned SearchLine, SearchColumn; 6101 CXFile ResultFile; 6102 unsigned ResultLine, ResultColumn; 6103 CXString SearchFileName, ResultFileName, KindSpelling, USR; 6104 const char *IsDef = clang_isCursorDefinition(Result) ? " (Definition)" : ""; 6105 CXSourceLocation ResultLoc = clang_getCursorLocation(Result); 6106 6107 clang_getFileLocation(Loc, &SearchFile, &SearchLine, &SearchColumn, 6108 nullptr); 6109 clang_getFileLocation(ResultLoc, &ResultFile, &ResultLine, &ResultColumn, 6110 nullptr); 6111 SearchFileName = clang_getFileName(SearchFile); 6112 ResultFileName = clang_getFileName(ResultFile); 6113 KindSpelling = clang_getCursorKindSpelling(Result.kind); 6114 USR = clang_getCursorUSR(Result); 6115 *Log << llvm::format("(%s:%d:%d) = %s", clang_getCString(SearchFileName), 6116 SearchLine, SearchColumn, 6117 clang_getCString(KindSpelling)) 6118 << llvm::format("(%s:%d:%d):%s%s", clang_getCString(ResultFileName), 6119 ResultLine, ResultColumn, clang_getCString(USR), 6120 IsDef); 6121 clang_disposeString(SearchFileName); 6122 clang_disposeString(ResultFileName); 6123 clang_disposeString(KindSpelling); 6124 clang_disposeString(USR); 6125 6126 CXCursor Definition = clang_getCursorDefinition(Result); 6127 if (!clang_equalCursors(Definition, clang_getNullCursor())) { 6128 CXSourceLocation DefinitionLoc = clang_getCursorLocation(Definition); 6129 CXString DefinitionKindSpelling = 6130 clang_getCursorKindSpelling(Definition.kind); 6131 CXFile DefinitionFile; 6132 unsigned DefinitionLine, DefinitionColumn; 6133 clang_getFileLocation(DefinitionLoc, &DefinitionFile, &DefinitionLine, 6134 &DefinitionColumn, nullptr); 6135 CXString DefinitionFileName = clang_getFileName(DefinitionFile); 6136 *Log << llvm::format(" -> %s(%s:%d:%d)", 6137 clang_getCString(DefinitionKindSpelling), 6138 clang_getCString(DefinitionFileName), DefinitionLine, 6139 DefinitionColumn); 6140 clang_disposeString(DefinitionFileName); 6141 clang_disposeString(DefinitionKindSpelling); 6142 } 6143 } 6144 6145 return Result; 6146} 6147 6148CXCursor clang_getNullCursor(void) { 6149 return MakeCXCursorInvalid(CXCursor_InvalidFile); 6150} 6151 6152unsigned clang_equalCursors(CXCursor X, CXCursor Y) { 6153 // Clear out the "FirstInDeclGroup" part in a declaration cursor, since we 6154 // can't set consistently. For example, when visiting a DeclStmt we will set 6155 // it but we don't set it on the result of clang_getCursorDefinition for 6156 // a reference of the same declaration. 6157 // FIXME: Setting "FirstInDeclGroup" in CXCursors is a hack that only works 6158 // when visiting a DeclStmt currently, the AST should be enhanced to be able 6159 // to provide that kind of info. 6160 if (clang_isDeclaration(X.kind)) 6161 X.data[1] = nullptr; 6162 if (clang_isDeclaration(Y.kind)) 6163 Y.data[1] = nullptr; 6164 6165 return X == Y; 6166} 6167 6168unsigned clang_hashCursor(CXCursor C) { 6169 unsigned Index = 0; 6170 if (clang_isExpression(C.kind) || clang_isStatement(C.kind)) 6171 Index = 1; 6172 6173 return llvm::DenseMapInfo<std::pair<unsigned, const void *>>::getHashValue( 6174 std::make_pair(C.kind, C.data[Index])); 6175} 6176 6177unsigned clang_isInvalid(enum CXCursorKind K) { 6178 return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid; 6179} 6180 6181unsigned clang_isDeclaration(enum CXCursorKind K) { 6182 return (K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl) || 6183 (K >= CXCursor_FirstExtraDecl && K <= CXCursor_LastExtraDecl); 6184} 6185 6186unsigned clang_isInvalidDeclaration(CXCursor C) { 6187 if (clang_isDeclaration(C.kind)) { 6188 if (const Decl *D = getCursorDecl(C)) 6189 return D->isInvalidDecl(); 6190 } 6191 6192 return 0; 6193} 6194 6195unsigned clang_isReference(enum CXCursorKind K) { 6196 return K >= CXCursor_FirstRef && K <= CXCursor_LastRef; 6197} 6198 6199unsigned clang_isExpression(enum CXCursorKind K) { 6200 return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr; 6201} 6202 6203unsigned clang_isStatement(enum CXCursorKind K) { 6204 return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt; 6205} 6206 6207unsigned clang_isAttribute(enum CXCursorKind K) { 6208 return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr; 6209} 6210 6211unsigned clang_isTranslationUnit(enum CXCursorKind K) { 6212 return K == CXCursor_TranslationUnit; 6213} 6214 6215unsigned clang_isPreprocessing(enum CXCursorKind K) { 6216 return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing; 6217} 6218 6219unsigned clang_isUnexposed(enum CXCursorKind K) { 6220 switch (K) { 6221 case CXCursor_UnexposedDecl: 6222 case CXCursor_UnexposedExpr: 6223 case CXCursor_UnexposedStmt: 6224 case CXCursor_UnexposedAttr: 6225 return true; 6226 default: 6227 return false; 6228 } 6229} 6230 6231CXCursorKind clang_getCursorKind(CXCursor C) { return C.kind; } 6232 6233CXSourceLocation clang_getCursorLocation(CXCursor C) { 6234 if (clang_isReference(C.kind)) { 6235 switch (C.kind) { 6236 case CXCursor_ObjCSuperClassRef: { 6237 std::pair<const ObjCInterfaceDecl *, SourceLocation> P = 6238 getCursorObjCSuperClassRef(C); 6239 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 6240 } 6241 6242 case CXCursor_ObjCProtocolRef: { 6243 std::pair<const ObjCProtocolDecl *, SourceLocation> P = 6244 getCursorObjCProtocolRef(C); 6245 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 6246 } 6247 6248 case CXCursor_ObjCClassRef: { 6249 std::pair<const ObjCInterfaceDecl *, SourceLocation> P = 6250 getCursorObjCClassRef(C); 6251 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 6252 } 6253 6254 case CXCursor_TypeRef: { 6255 std::pair<const TypeDecl *, SourceLocation> P = getCursorTypeRef(C); 6256 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 6257 } 6258 6259 case CXCursor_TemplateRef: { 6260 std::pair<const TemplateDecl *, SourceLocation> P = 6261 getCursorTemplateRef(C); 6262 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 6263 } 6264 6265 case CXCursor_NamespaceRef: { 6266 std::pair<const NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C); 6267 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 6268 } 6269 6270 case CXCursor_MemberRef: { 6271 std::pair<const FieldDecl *, SourceLocation> P = getCursorMemberRef(C); 6272 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 6273 } 6274 6275 case CXCursor_VariableRef: { 6276 std::pair<const VarDecl *, SourceLocation> P = getCursorVariableRef(C); 6277 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 6278 } 6279 6280 case CXCursor_CXXBaseSpecifier: { 6281 const CXXBaseSpecifier *BaseSpec = getCursorCXXBaseSpecifier(C); 6282 if (!BaseSpec) 6283 return clang_getNullLocation(); 6284 6285 if (TypeSourceInfo *TSInfo = BaseSpec->getTypeSourceInfo()) 6286 return cxloc::translateSourceLocation( 6287 getCursorContext(C), TSInfo->getTypeLoc().getBeginLoc()); 6288 6289 return cxloc::translateSourceLocation(getCursorContext(C), 6290 BaseSpec->getBeginLoc()); 6291 } 6292 6293 case CXCursor_LabelRef: { 6294 std::pair<const LabelStmt *, SourceLocation> P = getCursorLabelRef(C); 6295 return cxloc::translateSourceLocation(getCursorContext(C), P.second); 6296 } 6297 6298 case CXCursor_OverloadedDeclRef: 6299 return cxloc::translateSourceLocation( 6300 getCursorContext(C), getCursorOverloadedDeclRef(C).second); 6301 6302 default: 6303 // FIXME: Need a way to enumerate all non-reference cases. 6304 llvm_unreachable("Missed a reference kind"); 6305 } 6306 } 6307 6308 if (clang_isExpression(C.kind)) 6309 return cxloc::translateSourceLocation( 6310 getCursorContext(C), getLocationFromExpr(getCursorExpr(C))); 6311 6312 if (clang_isStatement(C.kind)) 6313 return cxloc::translateSourceLocation(getCursorContext(C), 6314 getCursorStmt(C)->getBeginLoc()); 6315 6316 if (C.kind == CXCursor_PreprocessingDirective) { 6317 SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin(); 6318 return cxloc::translateSourceLocation(getCursorContext(C), L); 6319 } 6320 6321 if (C.kind == CXCursor_MacroExpansion) { 6322 SourceLocation L = 6323 cxcursor::getCursorMacroExpansion(C).getSourceRange().getBegin(); 6324 return cxloc::translateSourceLocation(getCursorContext(C), L); 6325 } 6326 6327 if (C.kind == CXCursor_MacroDefinition) { 6328 SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation(); 6329 return cxloc::translateSourceLocation(getCursorContext(C), L); 6330 } 6331 6332 if (C.kind == CXCursor_InclusionDirective) { 6333 SourceLocation L = 6334 cxcursor::getCursorInclusionDirective(C)->getSourceRange().getBegin(); 6335 return cxloc::translateSourceLocation(getCursorContext(C), L); 6336 } 6337 6338 if (clang_isAttribute(C.kind)) { 6339 SourceLocation L = cxcursor::getCursorAttr(C)->getLocation(); 6340 return cxloc::translateSourceLocation(getCursorContext(C), L); 6341 } 6342 6343 if (!clang_isDeclaration(C.kind)) 6344 return clang_getNullLocation(); 6345 6346 const Decl *D = getCursorDecl(C); 6347 if (!D) 6348 return clang_getNullLocation(); 6349 6350 SourceLocation Loc = D->getLocation(); 6351 // FIXME: Multiple variables declared in a single declaration 6352 // currently lack the information needed to correctly determine their 6353 // ranges when accounting for the type-specifier. We use context 6354 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 6355 // and if so, whether it is the first decl. 6356 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 6357 if (!cxcursor::isFirstInDeclGroup(C)) 6358 Loc = VD->getLocation(); 6359 } 6360 6361 // For ObjC methods, give the start location of the method name. 6362 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 6363 Loc = MD->getSelectorStartLoc(); 6364 6365 return cxloc::translateSourceLocation(getCursorContext(C), Loc); 6366} 6367 6368} // end extern "C" 6369 6370CXCursor cxcursor::getCursor(CXTranslationUnit TU, SourceLocation SLoc) { 6371 assert(TU); 6372 6373 // Guard against an invalid SourceLocation, or we may assert in one 6374 // of the following calls. 6375 if (SLoc.isInvalid()) 6376 return clang_getNullCursor(); 6377 6378 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 6379 6380 // Translate the given source location to make it point at the beginning of 6381 // the token under the cursor. 6382 SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(), 6383 CXXUnit->getASTContext().getLangOpts()); 6384 6385 CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound); 6386 if (SLoc.isValid()) { 6387 GetCursorData ResultData(CXXUnit->getSourceManager(), SLoc, Result); 6388 CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData, 6389 /*VisitPreprocessorLast=*/true, 6390 /*VisitIncludedEntities=*/false, 6391 SourceLocation(SLoc)); 6392 CursorVis.visitFileRegion(); 6393 } 6394 6395 return Result; 6396} 6397 6398static SourceRange getRawCursorExtent(CXCursor C) { 6399 if (clang_isReference(C.kind)) { 6400 switch (C.kind) { 6401 case CXCursor_ObjCSuperClassRef: 6402 return getCursorObjCSuperClassRef(C).second; 6403 6404 case CXCursor_ObjCProtocolRef: 6405 return getCursorObjCProtocolRef(C).second; 6406 6407 case CXCursor_ObjCClassRef: 6408 return getCursorObjCClassRef(C).second; 6409 6410 case CXCursor_TypeRef: 6411 return getCursorTypeRef(C).second; 6412 6413 case CXCursor_TemplateRef: 6414 return getCursorTemplateRef(C).second; 6415 6416 case CXCursor_NamespaceRef: 6417 return getCursorNamespaceRef(C).second; 6418 6419 case CXCursor_MemberRef: 6420 return getCursorMemberRef(C).second; 6421 6422 case CXCursor_CXXBaseSpecifier: 6423 return getCursorCXXBaseSpecifier(C)->getSourceRange(); 6424 6425 case CXCursor_LabelRef: 6426 return getCursorLabelRef(C).second; 6427 6428 case CXCursor_OverloadedDeclRef: 6429 return getCursorOverloadedDeclRef(C).second; 6430 6431 case CXCursor_VariableRef: 6432 return getCursorVariableRef(C).second; 6433 6434 default: 6435 // FIXME: Need a way to enumerate all non-reference cases. 6436 llvm_unreachable("Missed a reference kind"); 6437 } 6438 } 6439 6440 if (clang_isExpression(C.kind)) 6441 return getCursorExpr(C)->getSourceRange(); 6442 6443 if (clang_isStatement(C.kind)) 6444 return getCursorStmt(C)->getSourceRange(); 6445 6446 if (clang_isAttribute(C.kind)) 6447 return getCursorAttr(C)->getRange(); 6448 6449 if (C.kind == CXCursor_PreprocessingDirective) 6450 return cxcursor::getCursorPreprocessingDirective(C); 6451 6452 if (C.kind == CXCursor_MacroExpansion) { 6453 ASTUnit *TU = getCursorASTUnit(C); 6454 SourceRange Range = cxcursor::getCursorMacroExpansion(C).getSourceRange(); 6455 return TU->mapRangeFromPreamble(Range); 6456 } 6457 6458 if (C.kind == CXCursor_MacroDefinition) { 6459 ASTUnit *TU = getCursorASTUnit(C); 6460 SourceRange Range = cxcursor::getCursorMacroDefinition(C)->getSourceRange(); 6461 return TU->mapRangeFromPreamble(Range); 6462 } 6463 6464 if (C.kind == CXCursor_InclusionDirective) { 6465 ASTUnit *TU = getCursorASTUnit(C); 6466 SourceRange Range = 6467 cxcursor::getCursorInclusionDirective(C)->getSourceRange(); 6468 return TU->mapRangeFromPreamble(Range); 6469 } 6470 6471 if (C.kind == CXCursor_TranslationUnit) { 6472 ASTUnit *TU = getCursorASTUnit(C); 6473 FileID MainID = TU->getSourceManager().getMainFileID(); 6474 SourceLocation Start = TU->getSourceManager().getLocForStartOfFile(MainID); 6475 SourceLocation End = TU->getSourceManager().getLocForEndOfFile(MainID); 6476 return SourceRange(Start, End); 6477 } 6478 6479 if (clang_isDeclaration(C.kind)) { 6480 const Decl *D = cxcursor::getCursorDecl(C); 6481 if (!D) 6482 return SourceRange(); 6483 6484 SourceRange R = D->getSourceRange(); 6485 // FIXME: Multiple variables declared in a single declaration 6486 // currently lack the information needed to correctly determine their 6487 // ranges when accounting for the type-specifier. We use context 6488 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 6489 // and if so, whether it is the first decl. 6490 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 6491 if (!cxcursor::isFirstInDeclGroup(C)) 6492 R.setBegin(VD->getLocation()); 6493 } 6494 return R; 6495 } 6496 return SourceRange(); 6497} 6498 6499/// Retrieves the "raw" cursor extent, which is then extended to include 6500/// the decl-specifier-seq for declarations. 6501static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) { 6502 if (clang_isDeclaration(C.kind)) { 6503 const Decl *D = cxcursor::getCursorDecl(C); 6504 if (!D) 6505 return SourceRange(); 6506 6507 SourceRange R = D->getSourceRange(); 6508 6509 // Adjust the start of the location for declarations preceded by 6510 // declaration specifiers. 6511 SourceLocation StartLoc; 6512 if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) { 6513 if (TypeSourceInfo *TI = DD->getTypeSourceInfo()) 6514 StartLoc = TI->getTypeLoc().getBeginLoc(); 6515 } else if (const TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) { 6516 if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo()) 6517 StartLoc = TI->getTypeLoc().getBeginLoc(); 6518 } 6519 6520 if (StartLoc.isValid() && R.getBegin().isValid() && 6521 SrcMgr.isBeforeInTranslationUnit(StartLoc, R.getBegin())) 6522 R.setBegin(StartLoc); 6523 6524 // FIXME: Multiple variables declared in a single declaration 6525 // currently lack the information needed to correctly determine their 6526 // ranges when accounting for the type-specifier. We use context 6527 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 6528 // and if so, whether it is the first decl. 6529 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 6530 if (!cxcursor::isFirstInDeclGroup(C)) 6531 R.setBegin(VD->getLocation()); 6532 } 6533 6534 return R; 6535 } 6536 6537 return getRawCursorExtent(C); 6538} 6539 6540CXSourceRange clang_getCursorExtent(CXCursor C) { 6541 SourceRange R = getRawCursorExtent(C); 6542 if (R.isInvalid()) 6543 return clang_getNullRange(); 6544 6545 return cxloc::translateSourceRange(getCursorContext(C), R); 6546} 6547 6548CXCursor clang_getCursorReferenced(CXCursor C) { 6549 if (clang_isInvalid(C.kind)) 6550 return clang_getNullCursor(); 6551 6552 CXTranslationUnit tu = getCursorTU(C); 6553 if (clang_isDeclaration(C.kind)) { 6554 const Decl *D = getCursorDecl(C); 6555 if (!D) 6556 return clang_getNullCursor(); 6557 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) 6558 return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu); 6559 if (const ObjCPropertyImplDecl *PropImpl = 6560 dyn_cast<ObjCPropertyImplDecl>(D)) 6561 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 6562 return MakeCXCursor(Property, tu); 6563 6564 return C; 6565 } 6566 6567 if (clang_isExpression(C.kind)) { 6568 const Expr *E = getCursorExpr(C); 6569 const Decl *D = getDeclFromExpr(E); 6570 if (D) { 6571 CXCursor declCursor = MakeCXCursor(D, tu); 6572 declCursor = getSelectorIdentifierCursor(getSelectorIdentifierIndex(C), 6573 declCursor); 6574 return declCursor; 6575 } 6576 6577 if (const OverloadExpr *Ovl = dyn_cast_or_null<OverloadExpr>(E)) 6578 return MakeCursorOverloadedDeclRef(Ovl, tu); 6579 6580 return clang_getNullCursor(); 6581 } 6582 6583 if (clang_isStatement(C.kind)) { 6584 const Stmt *S = getCursorStmt(C); 6585 if (const GotoStmt *Goto = dyn_cast_or_null<GotoStmt>(S)) 6586 if (LabelDecl *label = Goto->getLabel()) 6587 if (LabelStmt *labelS = label->getStmt()) 6588 return MakeCXCursor(labelS, getCursorDecl(C), tu); 6589 6590 return clang_getNullCursor(); 6591 } 6592 6593 if (C.kind == CXCursor_MacroExpansion) { 6594 if (const MacroDefinitionRecord *Def = 6595 getCursorMacroExpansion(C).getDefinition()) 6596 return MakeMacroDefinitionCursor(Def, tu); 6597 } 6598 6599 if (!clang_isReference(C.kind)) 6600 return clang_getNullCursor(); 6601 6602 switch (C.kind) { 6603 case CXCursor_ObjCSuperClassRef: 6604 return MakeCXCursor(getCursorObjCSuperClassRef(C).first, tu); 6605 6606 case CXCursor_ObjCProtocolRef: { 6607 const ObjCProtocolDecl *Prot = getCursorObjCProtocolRef(C).first; 6608 if (const ObjCProtocolDecl *Def = Prot->getDefinition()) 6609 return MakeCXCursor(Def, tu); 6610 6611 return MakeCXCursor(Prot, tu); 6612 } 6613 6614 case CXCursor_ObjCClassRef: { 6615 const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first; 6616 if (const ObjCInterfaceDecl *Def = Class->getDefinition()) 6617 return MakeCXCursor(Def, tu); 6618 6619 return MakeCXCursor(Class, tu); 6620 } 6621 6622 case CXCursor_TypeRef: 6623 return MakeCXCursor(getCursorTypeRef(C).first, tu); 6624 6625 case CXCursor_TemplateRef: 6626 return MakeCXCursor(getCursorTemplateRef(C).first, tu); 6627 6628 case CXCursor_NamespaceRef: 6629 return MakeCXCursor(getCursorNamespaceRef(C).first, tu); 6630 6631 case CXCursor_MemberRef: 6632 return MakeCXCursor(getCursorMemberRef(C).first, tu); 6633 6634 case CXCursor_CXXBaseSpecifier: { 6635 const CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C); 6636 return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(), tu)); 6637 } 6638 6639 case CXCursor_LabelRef: 6640 // FIXME: We end up faking the "parent" declaration here because we 6641 // don't want to make CXCursor larger. 6642 return MakeCXCursor( 6643 getCursorLabelRef(C).first, 6644 cxtu::getASTUnit(tu)->getASTContext().getTranslationUnitDecl(), tu); 6645 6646 case CXCursor_OverloadedDeclRef: 6647 return C; 6648 6649 case CXCursor_VariableRef: 6650 return MakeCXCursor(getCursorVariableRef(C).first, tu); 6651 6652 default: 6653 // We would prefer to enumerate all non-reference cursor kinds here. 6654 llvm_unreachable("Unhandled reference cursor kind"); 6655 } 6656} 6657 6658CXCursor clang_getCursorDefinition(CXCursor C) { 6659 if (clang_isInvalid(C.kind)) 6660 return clang_getNullCursor(); 6661 6662 CXTranslationUnit TU = getCursorTU(C); 6663 6664 bool WasReference = false; 6665 if (clang_isReference(C.kind) || clang_isExpression(C.kind)) { 6666 C = clang_getCursorReferenced(C); 6667 WasReference = true; 6668 } 6669 6670 if (C.kind == CXCursor_MacroExpansion) 6671 return clang_getCursorReferenced(C); 6672 6673 if (!clang_isDeclaration(C.kind)) 6674 return clang_getNullCursor(); 6675 6676 const Decl *D = getCursorDecl(C); 6677 if (!D) 6678 return clang_getNullCursor(); 6679 6680 switch (D->getKind()) { 6681 // Declaration kinds that don't really separate the notions of 6682 // declaration and definition. 6683 case Decl::Namespace: 6684 case Decl::Typedef: 6685 case Decl::TypeAlias: 6686 case Decl::TypeAliasTemplate: 6687 case Decl::TemplateTypeParm: 6688 case Decl::EnumConstant: 6689 case Decl::Field: 6690 case Decl::Binding: 6691 case Decl::MSProperty: 6692 case Decl::MSGuid: 6693 case Decl::HLSLBuffer: 6694 case Decl::UnnamedGlobalConstant: 6695 case Decl::TemplateParamObject: 6696 case Decl::IndirectField: 6697 case Decl::ObjCIvar: 6698 case Decl::ObjCAtDefsField: 6699 case Decl::ImplicitParam: 6700 case Decl::ParmVar: 6701 case Decl::NonTypeTemplateParm: 6702 case Decl::TemplateTemplateParm: 6703 case Decl::ObjCCategoryImpl: 6704 case Decl::ObjCImplementation: 6705 case Decl::AccessSpec: 6706 case Decl::LinkageSpec: 6707 case Decl::Export: 6708 case Decl::ObjCPropertyImpl: 6709 case Decl::FileScopeAsm: 6710 case Decl::TopLevelStmt: 6711 case Decl::StaticAssert: 6712 case Decl::Block: 6713 case Decl::Captured: 6714 case Decl::OMPCapturedExpr: 6715 case Decl::Label: // FIXME: Is this right?? 6716 case Decl::ClassScopeFunctionSpecialization: 6717 case Decl::CXXDeductionGuide: 6718 case Decl::Import: 6719 case Decl::OMPThreadPrivate: 6720 case Decl::OMPAllocate: 6721 case Decl::OMPDeclareReduction: 6722 case Decl::OMPDeclareMapper: 6723 case Decl::OMPRequires: 6724 case Decl::ObjCTypeParam: 6725 case Decl::BuiltinTemplate: 6726 case Decl::PragmaComment: 6727 case Decl::PragmaDetectMismatch: 6728 case Decl::UsingPack: 6729 case Decl::Concept: 6730 case Decl::ImplicitConceptSpecialization: 6731 case Decl::LifetimeExtendedTemporary: 6732 case Decl::RequiresExprBody: 6733 case Decl::UnresolvedUsingIfExists: 6734 return C; 6735 6736 // Declaration kinds that don't make any sense here, but are 6737 // nonetheless harmless. 6738 case Decl::Empty: 6739 case Decl::TranslationUnit: 6740 case Decl::ExternCContext: 6741 break; 6742 6743 // Declaration kinds for which the definition is not resolvable. 6744 case Decl::UnresolvedUsingTypename: 6745 case Decl::UnresolvedUsingValue: 6746 break; 6747 6748 case Decl::UsingDirective: 6749 return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(), 6750 TU); 6751 6752 case Decl::NamespaceAlias: 6753 return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), TU); 6754 6755 case Decl::Enum: 6756 case Decl::Record: 6757 case Decl::CXXRecord: 6758 case Decl::ClassTemplateSpecialization: 6759 case Decl::ClassTemplatePartialSpecialization: 6760 if (TagDecl *Def = cast<TagDecl>(D)->getDefinition()) 6761 return MakeCXCursor(Def, TU); 6762 return clang_getNullCursor(); 6763 6764 case Decl::Function: 6765 case Decl::CXXMethod: 6766 case Decl::CXXConstructor: 6767 case Decl::CXXDestructor: 6768 case Decl::CXXConversion: { 6769 const FunctionDecl *Def = nullptr; 6770 if (cast<FunctionDecl>(D)->getBody(Def)) 6771 return MakeCXCursor(Def, TU); 6772 return clang_getNullCursor(); 6773 } 6774 6775 case Decl::Var: 6776 case Decl::VarTemplateSpecialization: 6777 case Decl::VarTemplatePartialSpecialization: 6778 case Decl::Decomposition: { 6779 // Ask the variable if it has a definition. 6780 if (const VarDecl *Def = cast<VarDecl>(D)->getDefinition()) 6781 return MakeCXCursor(Def, TU); 6782 return clang_getNullCursor(); 6783 } 6784 6785 case Decl::FunctionTemplate: { 6786 const FunctionDecl *Def = nullptr; 6787 if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def)) 6788 return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU); 6789 return clang_getNullCursor(); 6790 } 6791 6792 case Decl::ClassTemplate: { 6793 if (RecordDecl *Def = 6794 cast<ClassTemplateDecl>(D)->getTemplatedDecl()->getDefinition()) 6795 return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(), 6796 TU); 6797 return clang_getNullCursor(); 6798 } 6799 6800 case Decl::VarTemplate: { 6801 if (VarDecl *Def = 6802 cast<VarTemplateDecl>(D)->getTemplatedDecl()->getDefinition()) 6803 return MakeCXCursor(cast<VarDecl>(Def)->getDescribedVarTemplate(), TU); 6804 return clang_getNullCursor(); 6805 } 6806 6807 case Decl::Using: 6808 case Decl::UsingEnum: 6809 return MakeCursorOverloadedDeclRef(cast<BaseUsingDecl>(D), D->getLocation(), 6810 TU); 6811 6812 case Decl::UsingShadow: 6813 case Decl::ConstructorUsingShadow: 6814 return clang_getCursorDefinition( 6815 MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(), TU)); 6816 6817 case Decl::ObjCMethod: { 6818 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D); 6819 if (Method->isThisDeclarationADefinition()) 6820 return C; 6821 6822 // Dig out the method definition in the associated 6823 // @implementation, if we have it. 6824 // FIXME: The ASTs should make finding the definition easier. 6825 if (const ObjCInterfaceDecl *Class = 6826 dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) 6827 if (ObjCImplementationDecl *ClassImpl = Class->getImplementation()) 6828 if (ObjCMethodDecl *Def = ClassImpl->getMethod( 6829 Method->getSelector(), Method->isInstanceMethod())) 6830 if (Def->isThisDeclarationADefinition()) 6831 return MakeCXCursor(Def, TU); 6832 6833 return clang_getNullCursor(); 6834 } 6835 6836 case Decl::ObjCCategory: 6837 if (ObjCCategoryImplDecl *Impl = 6838 cast<ObjCCategoryDecl>(D)->getImplementation()) 6839 return MakeCXCursor(Impl, TU); 6840 return clang_getNullCursor(); 6841 6842 case Decl::ObjCProtocol: 6843 if (const ObjCProtocolDecl *Def = 6844 cast<ObjCProtocolDecl>(D)->getDefinition()) 6845 return MakeCXCursor(Def, TU); 6846 return clang_getNullCursor(); 6847 6848 case Decl::ObjCInterface: { 6849 // There are two notions of a "definition" for an Objective-C 6850 // class: the interface and its implementation. When we resolved a 6851 // reference to an Objective-C class, produce the @interface as 6852 // the definition; when we were provided with the interface, 6853 // produce the @implementation as the definition. 6854 const ObjCInterfaceDecl *IFace = cast<ObjCInterfaceDecl>(D); 6855 if (WasReference) { 6856 if (const ObjCInterfaceDecl *Def = IFace->getDefinition()) 6857 return MakeCXCursor(Def, TU); 6858 } else if (ObjCImplementationDecl *Impl = IFace->getImplementation()) 6859 return MakeCXCursor(Impl, TU); 6860 return clang_getNullCursor(); 6861 } 6862 6863 case Decl::ObjCProperty: 6864 // FIXME: We don't really know where to find the 6865 // ObjCPropertyImplDecls that implement this property. 6866 return clang_getNullCursor(); 6867 6868 case Decl::ObjCCompatibleAlias: 6869 if (const ObjCInterfaceDecl *Class = 6870 cast<ObjCCompatibleAliasDecl>(D)->getClassInterface()) 6871 if (const ObjCInterfaceDecl *Def = Class->getDefinition()) 6872 return MakeCXCursor(Def, TU); 6873 6874 return clang_getNullCursor(); 6875 6876 case Decl::Friend: 6877 if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl()) 6878 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 6879 return clang_getNullCursor(); 6880 6881 case Decl::FriendTemplate: 6882 if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl()) 6883 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 6884 return clang_getNullCursor(); 6885 } 6886 6887 return clang_getNullCursor(); 6888} 6889 6890unsigned clang_isCursorDefinition(CXCursor C) { 6891 if (!clang_isDeclaration(C.kind)) 6892 return 0; 6893 6894 return clang_getCursorDefinition(C) == C; 6895} 6896 6897CXCursor clang_getCanonicalCursor(CXCursor C) { 6898 if (!clang_isDeclaration(C.kind)) 6899 return C; 6900 6901 if (const Decl *D = getCursorDecl(C)) { 6902 if (const ObjCCategoryImplDecl *CatImplD = 6903 dyn_cast<ObjCCategoryImplDecl>(D)) 6904 if (ObjCCategoryDecl *CatD = CatImplD->getCategoryDecl()) 6905 return MakeCXCursor(CatD, getCursorTU(C)); 6906 6907 if (const ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 6908 if (const ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) 6909 return MakeCXCursor(IFD, getCursorTU(C)); 6910 6911 return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C)); 6912 } 6913 6914 return C; 6915} 6916 6917int clang_Cursor_getObjCSelectorIndex(CXCursor cursor) { 6918 return cxcursor::getSelectorIdentifierIndexAndLoc(cursor).first; 6919} 6920 6921unsigned clang_getNumOverloadedDecls(CXCursor C) { 6922 if (C.kind != CXCursor_OverloadedDeclRef) 6923 return 0; 6924 6925 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 6926 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>()) 6927 return E->getNumDecls(); 6928 6929 if (OverloadedTemplateStorage *S = 6930 Storage.dyn_cast<OverloadedTemplateStorage *>()) 6931 return S->size(); 6932 6933 const Decl *D = Storage.get<const Decl *>(); 6934 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) 6935 return Using->shadow_size(); 6936 6937 return 0; 6938} 6939 6940CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) { 6941 if (cursor.kind != CXCursor_OverloadedDeclRef) 6942 return clang_getNullCursor(); 6943 6944 if (index >= clang_getNumOverloadedDecls(cursor)) 6945 return clang_getNullCursor(); 6946 6947 CXTranslationUnit TU = getCursorTU(cursor); 6948 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first; 6949 if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>()) 6950 return MakeCXCursor(E->decls_begin()[index], TU); 6951 6952 if (OverloadedTemplateStorage *S = 6953 Storage.dyn_cast<OverloadedTemplateStorage *>()) 6954 return MakeCXCursor(S->begin()[index], TU); 6955 6956 const Decl *D = Storage.get<const Decl *>(); 6957 if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) { 6958 // FIXME: This is, unfortunately, linear time. 6959 UsingDecl::shadow_iterator Pos = Using->shadow_begin(); 6960 std::advance(Pos, index); 6961 return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU); 6962 } 6963 6964 return clang_getNullCursor(); 6965} 6966 6967void clang_getDefinitionSpellingAndExtent( 6968 CXCursor C, const char **startBuf, const char **endBuf, unsigned *startLine, 6969 unsigned *startColumn, unsigned *endLine, unsigned *endColumn) { 6970 assert(getCursorDecl(C) && "CXCursor has null decl"); 6971 const auto *FD = cast<FunctionDecl>(getCursorDecl(C)); 6972 const auto *Body = cast<CompoundStmt>(FD->getBody()); 6973 6974 SourceManager &SM = FD->getASTContext().getSourceManager(); 6975 *startBuf = SM.getCharacterData(Body->getLBracLoc()); 6976 *endBuf = SM.getCharacterData(Body->getRBracLoc()); 6977 *startLine = SM.getSpellingLineNumber(Body->getLBracLoc()); 6978 *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc()); 6979 *endLine = SM.getSpellingLineNumber(Body->getRBracLoc()); 6980 *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc()); 6981} 6982 6983CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags, 6984 unsigned PieceIndex) { 6985 RefNamePieces Pieces; 6986 6987 switch (C.kind) { 6988 case CXCursor_MemberRefExpr: 6989 if (const MemberExpr *E = dyn_cast<MemberExpr>(getCursorExpr(C))) 6990 Pieces = buildPieces(NameFlags, true, E->getMemberNameInfo(), 6991 E->getQualifierLoc().getSourceRange()); 6992 break; 6993 6994 case CXCursor_DeclRefExpr: 6995 if (const DeclRefExpr *E = dyn_cast<DeclRefExpr>(getCursorExpr(C))) { 6996 SourceRange TemplateArgLoc(E->getLAngleLoc(), E->getRAngleLoc()); 6997 Pieces = 6998 buildPieces(NameFlags, false, E->getNameInfo(), 6999 E->getQualifierLoc().getSourceRange(), &TemplateArgLoc); 7000 } 7001 break; 7002 7003 case CXCursor_CallExpr: 7004 if (const CXXOperatorCallExpr *OCE = 7005 dyn_cast<CXXOperatorCallExpr>(getCursorExpr(C))) { 7006 const Expr *Callee = OCE->getCallee(); 7007 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee)) 7008 Callee = ICE->getSubExpr(); 7009 7010 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) 7011 Pieces = buildPieces(NameFlags, false, DRE->getNameInfo(), 7012 DRE->getQualifierLoc().getSourceRange()); 7013 } 7014 break; 7015 7016 default: 7017 break; 7018 } 7019 7020 if (Pieces.empty()) { 7021 if (PieceIndex == 0) 7022 return clang_getCursorExtent(C); 7023 } else if (PieceIndex < Pieces.size()) { 7024 SourceRange R = Pieces[PieceIndex]; 7025 if (R.isValid()) 7026 return cxloc::translateSourceRange(getCursorContext(C), R); 7027 } 7028 7029 return clang_getNullRange(); 7030} 7031 7032void clang_enableStackTraces(void) { 7033 // FIXME: Provide an argv0 here so we can find llvm-symbolizer. 7034 llvm::sys::PrintStackTraceOnErrorSignal(StringRef()); 7035} 7036 7037void clang_executeOnThread(void (*fn)(void *), void *user_data, 7038 unsigned stack_size) { 7039 llvm::thread Thread(stack_size == 0 ? clang::DesiredStackSize 7040 : std::optional<unsigned>(stack_size), 7041 fn, user_data); 7042 Thread.join(); 7043} 7044 7045//===----------------------------------------------------------------------===// 7046// Token-based Operations. 7047//===----------------------------------------------------------------------===// 7048 7049/* CXToken layout: 7050 * int_data[0]: a CXTokenKind 7051 * int_data[1]: starting token location 7052 * int_data[2]: token length 7053 * int_data[3]: reserved 7054 * ptr_data: for identifiers and keywords, an IdentifierInfo*. 7055 * otherwise unused. 7056 */ 7057CXTokenKind clang_getTokenKind(CXToken CXTok) { 7058 return static_cast<CXTokenKind>(CXTok.int_data[0]); 7059} 7060 7061CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) { 7062 switch (clang_getTokenKind(CXTok)) { 7063 case CXToken_Identifier: 7064 case CXToken_Keyword: 7065 // We know we have an IdentifierInfo*, so use that. 7066 return cxstring::createRef( 7067 static_cast<IdentifierInfo *>(CXTok.ptr_data)->getNameStart()); 7068 7069 case CXToken_Literal: { 7070 // We have stashed the starting pointer in the ptr_data field. Use it. 7071 const char *Text = static_cast<const char *>(CXTok.ptr_data); 7072 return cxstring::createDup(StringRef(Text, CXTok.int_data[2])); 7073 } 7074 7075 case CXToken_Punctuation: 7076 case CXToken_Comment: 7077 break; 7078 } 7079 7080 if (isNotUsableTU(TU)) { 7081 LOG_BAD_TU(TU); 7082 return cxstring::createEmpty(); 7083 } 7084 7085 // We have to find the starting buffer pointer the hard way, by 7086 // deconstructing the source location. 7087 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 7088 if (!CXXUnit) 7089 return cxstring::createEmpty(); 7090 7091 SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]); 7092 std::pair<FileID, unsigned> LocInfo = 7093 CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc); 7094 bool Invalid = false; 7095 StringRef Buffer = 7096 CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid); 7097 if (Invalid) 7098 return cxstring::createEmpty(); 7099 7100 return cxstring::createDup(Buffer.substr(LocInfo.second, CXTok.int_data[2])); 7101} 7102 7103CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) { 7104 if (isNotUsableTU(TU)) { 7105 LOG_BAD_TU(TU); 7106 return clang_getNullLocation(); 7107 } 7108 7109 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 7110 if (!CXXUnit) 7111 return clang_getNullLocation(); 7112 7113 return cxloc::translateSourceLocation( 7114 CXXUnit->getASTContext(), 7115 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 7116} 7117 7118CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) { 7119 if (isNotUsableTU(TU)) { 7120 LOG_BAD_TU(TU); 7121 return clang_getNullRange(); 7122 } 7123 7124 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 7125 if (!CXXUnit) 7126 return clang_getNullRange(); 7127 7128 return cxloc::translateSourceRange( 7129 CXXUnit->getASTContext(), 7130 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 7131} 7132 7133static void getTokens(ASTUnit *CXXUnit, SourceRange Range, 7134 SmallVectorImpl<CXToken> &CXTokens) { 7135 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 7136 std::pair<FileID, unsigned> BeginLocInfo = 7137 SourceMgr.getDecomposedSpellingLoc(Range.getBegin()); 7138 std::pair<FileID, unsigned> EndLocInfo = 7139 SourceMgr.getDecomposedSpellingLoc(Range.getEnd()); 7140 7141 // Cannot tokenize across files. 7142 if (BeginLocInfo.first != EndLocInfo.first) 7143 return; 7144 7145 // Create a lexer 7146 bool Invalid = false; 7147 StringRef Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid); 7148 if (Invalid) 7149 return; 7150 7151 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 7152 CXXUnit->getASTContext().getLangOpts(), Buffer.begin(), 7153 Buffer.data() + BeginLocInfo.second, Buffer.end()); 7154 Lex.SetCommentRetentionState(true); 7155 7156 // Lex tokens until we hit the end of the range. 7157 const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second; 7158 Token Tok; 7159 bool previousWasAt = false; 7160 do { 7161 // Lex the next token 7162 Lex.LexFromRawLexer(Tok); 7163 if (Tok.is(tok::eof)) 7164 break; 7165 7166 // Initialize the CXToken. 7167 CXToken CXTok; 7168 7169 // - Common fields 7170 CXTok.int_data[1] = Tok.getLocation().getRawEncoding(); 7171 CXTok.int_data[2] = Tok.getLength(); 7172 CXTok.int_data[3] = 0; 7173 7174 // - Kind-specific fields 7175 if (Tok.isLiteral()) { 7176 CXTok.int_data[0] = CXToken_Literal; 7177 CXTok.ptr_data = const_cast<char *>(Tok.getLiteralData()); 7178 } else if (Tok.is(tok::raw_identifier)) { 7179 // Lookup the identifier to determine whether we have a keyword. 7180 IdentifierInfo *II = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok); 7181 7182 if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) { 7183 CXTok.int_data[0] = CXToken_Keyword; 7184 } else { 7185 CXTok.int_data[0] = 7186 Tok.is(tok::identifier) ? CXToken_Identifier : CXToken_Keyword; 7187 } 7188 CXTok.ptr_data = II; 7189 } else if (Tok.is(tok::comment)) { 7190 CXTok.int_data[0] = CXToken_Comment; 7191 CXTok.ptr_data = nullptr; 7192 } else { 7193 CXTok.int_data[0] = CXToken_Punctuation; 7194 CXTok.ptr_data = nullptr; 7195 } 7196 CXTokens.push_back(CXTok); 7197 previousWasAt = Tok.is(tok::at); 7198 } while (Lex.getBufferLocation() < EffectiveBufferEnd); 7199} 7200 7201CXToken *clang_getToken(CXTranslationUnit TU, CXSourceLocation Location) { 7202 LOG_FUNC_SECTION { *Log << TU << ' ' << Location; } 7203 7204 if (isNotUsableTU(TU)) { 7205 LOG_BAD_TU(TU); 7206 return nullptr; 7207 } 7208 7209 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 7210 if (!CXXUnit) 7211 return nullptr; 7212 7213 SourceLocation Begin = cxloc::translateSourceLocation(Location); 7214 if (Begin.isInvalid()) 7215 return nullptr; 7216 SourceManager &SM = CXXUnit->getSourceManager(); 7217 std::pair<FileID, unsigned> DecomposedEnd = SM.getDecomposedLoc(Begin); 7218 DecomposedEnd.second += 7219 Lexer::MeasureTokenLength(Begin, SM, CXXUnit->getLangOpts()); 7220 7221 SourceLocation End = 7222 SM.getComposedLoc(DecomposedEnd.first, DecomposedEnd.second); 7223 7224 SmallVector<CXToken, 32> CXTokens; 7225 getTokens(CXXUnit, SourceRange(Begin, End), CXTokens); 7226 7227 if (CXTokens.empty()) 7228 return nullptr; 7229 7230 CXTokens.resize(1); 7231 CXToken *Token = static_cast<CXToken *>(llvm::safe_malloc(sizeof(CXToken))); 7232 7233 memmove(Token, CXTokens.data(), sizeof(CXToken)); 7234 return Token; 7235} 7236 7237void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range, CXToken **Tokens, 7238 unsigned *NumTokens) { 7239 LOG_FUNC_SECTION { *Log << TU << ' ' << Range; } 7240 7241 if (Tokens) 7242 *Tokens = nullptr; 7243 if (NumTokens) 7244 *NumTokens = 0; 7245 7246 if (isNotUsableTU(TU)) { 7247 LOG_BAD_TU(TU); 7248 return; 7249 } 7250 7251 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 7252 if (!CXXUnit || !Tokens || !NumTokens) 7253 return; 7254 7255 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 7256 7257 SourceRange R = cxloc::translateCXSourceRange(Range); 7258 if (R.isInvalid()) 7259 return; 7260 7261 SmallVector<CXToken, 32> CXTokens; 7262 getTokens(CXXUnit, R, CXTokens); 7263 7264 if (CXTokens.empty()) 7265 return; 7266 7267 *Tokens = static_cast<CXToken *>( 7268 llvm::safe_malloc(sizeof(CXToken) * CXTokens.size())); 7269 memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size()); 7270 *NumTokens = CXTokens.size(); 7271} 7272 7273void clang_disposeTokens(CXTranslationUnit TU, CXToken *Tokens, 7274 unsigned NumTokens) { 7275 free(Tokens); 7276} 7277 7278//===----------------------------------------------------------------------===// 7279// Token annotation APIs. 7280//===----------------------------------------------------------------------===// 7281 7282static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 7283 CXCursor parent, 7284 CXClientData client_data); 7285static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor, 7286 CXClientData client_data); 7287 7288namespace { 7289class AnnotateTokensWorker { 7290 CXToken *Tokens; 7291 CXCursor *Cursors; 7292 unsigned NumTokens; 7293 unsigned TokIdx; 7294 unsigned PreprocessingTokIdx; 7295 CursorVisitor AnnotateVis; 7296 SourceManager &SrcMgr; 7297 bool HasContextSensitiveKeywords; 7298 7299 struct PostChildrenAction { 7300 CXCursor cursor; 7301 enum Action { Invalid, Ignore, Postpone } action; 7302 }; 7303 using PostChildrenActions = SmallVector<PostChildrenAction, 0>; 7304 7305 struct PostChildrenInfo { 7306 CXCursor Cursor; 7307 SourceRange CursorRange; 7308 unsigned BeforeReachingCursorIdx; 7309 unsigned BeforeChildrenTokenIdx; 7310 PostChildrenActions ChildActions; 7311 }; 7312 SmallVector<PostChildrenInfo, 8> PostChildrenInfos; 7313 7314 CXToken &getTok(unsigned Idx) { 7315 assert(Idx < NumTokens); 7316 return Tokens[Idx]; 7317 } 7318 const CXToken &getTok(unsigned Idx) const { 7319 assert(Idx < NumTokens); 7320 return Tokens[Idx]; 7321 } 7322 bool MoreTokens() const { return TokIdx < NumTokens; } 7323 unsigned NextToken() const { return TokIdx; } 7324 void AdvanceToken() { ++TokIdx; } 7325 SourceLocation GetTokenLoc(unsigned tokI) { 7326 return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]); 7327 } 7328 bool isFunctionMacroToken(unsigned tokI) const { 7329 return getTok(tokI).int_data[3] != 0; 7330 } 7331 SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const { 7332 return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[3]); 7333 } 7334 7335 void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange); 7336 bool annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult, 7337 SourceRange); 7338 7339public: 7340 AnnotateTokensWorker(CXToken *tokens, CXCursor *cursors, unsigned numTokens, 7341 CXTranslationUnit TU, SourceRange RegionOfInterest) 7342 : Tokens(tokens), Cursors(cursors), NumTokens(numTokens), TokIdx(0), 7343 PreprocessingTokIdx(0), 7344 AnnotateVis(TU, AnnotateTokensVisitor, this, 7345 /*VisitPreprocessorLast=*/true, 7346 /*VisitIncludedEntities=*/false, RegionOfInterest, 7347 /*VisitDeclsOnly=*/false, 7348 AnnotateTokensPostChildrenVisitor), 7349 SrcMgr(cxtu::getASTUnit(TU)->getSourceManager()), 7350 HasContextSensitiveKeywords(false) {} 7351 7352 void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); } 7353 enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent); 7354 bool IsIgnoredChildCursor(CXCursor cursor) const; 7355 PostChildrenActions DetermineChildActions(CXCursor Cursor) const; 7356 7357 bool postVisitChildren(CXCursor cursor); 7358 void HandlePostPonedChildCursors(const PostChildrenInfo &Info); 7359 void HandlePostPonedChildCursor(CXCursor Cursor, unsigned StartTokenIndex); 7360 7361 void AnnotateTokens(); 7362 7363 /// Determine whether the annotator saw any cursors that have 7364 /// context-sensitive keywords. 7365 bool hasContextSensitiveKeywords() const { 7366 return HasContextSensitiveKeywords; 7367 } 7368 7369 ~AnnotateTokensWorker() { assert(PostChildrenInfos.empty()); } 7370}; 7371} // namespace 7372 7373void AnnotateTokensWorker::AnnotateTokens() { 7374 // Walk the AST within the region of interest, annotating tokens 7375 // along the way. 7376 AnnotateVis.visitFileRegion(); 7377} 7378 7379bool AnnotateTokensWorker::IsIgnoredChildCursor(CXCursor cursor) const { 7380 if (PostChildrenInfos.empty()) 7381 return false; 7382 7383 for (const auto &ChildAction : PostChildrenInfos.back().ChildActions) { 7384 if (ChildAction.cursor == cursor && 7385 ChildAction.action == PostChildrenAction::Ignore) { 7386 return true; 7387 } 7388 } 7389 7390 return false; 7391} 7392 7393const CXXOperatorCallExpr *GetSubscriptOrCallOperator(CXCursor Cursor) { 7394 if (!clang_isExpression(Cursor.kind)) 7395 return nullptr; 7396 7397 const Expr *E = getCursorExpr(Cursor); 7398 if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) { 7399 const OverloadedOperatorKind Kind = OCE->getOperator(); 7400 if (Kind == OO_Call || Kind == OO_Subscript) 7401 return OCE; 7402 } 7403 7404 return nullptr; 7405} 7406 7407AnnotateTokensWorker::PostChildrenActions 7408AnnotateTokensWorker::DetermineChildActions(CXCursor Cursor) const { 7409 PostChildrenActions actions; 7410 7411 // The DeclRefExpr of CXXOperatorCallExpr referring to the custom operator is 7412 // visited before the arguments to the operator call. For the Call and 7413 // Subscript operator the range of this DeclRefExpr includes the whole call 7414 // expression, so that all tokens in that range would be mapped to the 7415 // operator function, including the tokens of the arguments. To avoid that, 7416 // ensure to visit this DeclRefExpr as last node. 7417 if (const auto *OCE = GetSubscriptOrCallOperator(Cursor)) { 7418 const Expr *Callee = OCE->getCallee(); 7419 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee)) { 7420 const Expr *SubExpr = ICE->getSubExpr(); 7421 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(SubExpr)) { 7422 const Decl *parentDecl = getCursorDecl(Cursor); 7423 CXTranslationUnit TU = clang_Cursor_getTranslationUnit(Cursor); 7424 7425 // Visit the DeclRefExpr as last. 7426 CXCursor cxChild = MakeCXCursor(DRE, parentDecl, TU); 7427 actions.push_back({cxChild, PostChildrenAction::Postpone}); 7428 7429 // The parent of the DeclRefExpr, an ImplicitCastExpr, has an equally 7430 // wide range as the DeclRefExpr. We can skip visiting this entirely. 7431 cxChild = MakeCXCursor(ICE, parentDecl, TU); 7432 actions.push_back({cxChild, PostChildrenAction::Ignore}); 7433 } 7434 } 7435 } 7436 7437 return actions; 7438} 7439 7440static inline void updateCursorAnnotation(CXCursor &Cursor, 7441 const CXCursor &updateC) { 7442 if (clang_isInvalid(updateC.kind) || !clang_isInvalid(Cursor.kind)) 7443 return; 7444 Cursor = updateC; 7445} 7446 7447/// It annotates and advances tokens with a cursor until the comparison 7448//// between the cursor location and the source range is the same as 7449/// \arg compResult. 7450/// 7451/// Pass RangeBefore to annotate tokens with a cursor until a range is reached. 7452/// Pass RangeOverlap to annotate tokens inside a range. 7453void AnnotateTokensWorker::annotateAndAdvanceTokens( 7454 CXCursor updateC, RangeComparisonResult compResult, SourceRange range) { 7455 while (MoreTokens()) { 7456 const unsigned I = NextToken(); 7457 if (isFunctionMacroToken(I)) 7458 if (!annotateAndAdvanceFunctionMacroTokens(updateC, compResult, range)) 7459 return; 7460 7461 SourceLocation TokLoc = GetTokenLoc(I); 7462 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) { 7463 updateCursorAnnotation(Cursors[I], updateC); 7464 AdvanceToken(); 7465 continue; 7466 } 7467 break; 7468 } 7469} 7470 7471/// Special annotation handling for macro argument tokens. 7472/// \returns true if it advanced beyond all macro tokens, false otherwise. 7473bool AnnotateTokensWorker::annotateAndAdvanceFunctionMacroTokens( 7474 CXCursor updateC, RangeComparisonResult compResult, SourceRange range) { 7475 assert(MoreTokens()); 7476 assert(isFunctionMacroToken(NextToken()) && 7477 "Should be called only for macro arg tokens"); 7478 7479 // This works differently than annotateAndAdvanceTokens; because expanded 7480 // macro arguments can have arbitrary translation-unit source order, we do not 7481 // advance the token index one by one until a token fails the range test. 7482 // We only advance once past all of the macro arg tokens if all of them 7483 // pass the range test. If one of them fails we keep the token index pointing 7484 // at the start of the macro arg tokens so that the failing token will be 7485 // annotated by a subsequent annotation try. 7486 7487 bool atLeastOneCompFail = false; 7488 7489 unsigned I = NextToken(); 7490 for (; I < NumTokens && isFunctionMacroToken(I); ++I) { 7491 SourceLocation TokLoc = getFunctionMacroTokenLoc(I); 7492 if (TokLoc.isFileID()) 7493 continue; // not macro arg token, it's parens or comma. 7494 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) { 7495 if (clang_isInvalid(clang_getCursorKind(Cursors[I]))) 7496 Cursors[I] = updateC; 7497 } else 7498 atLeastOneCompFail = true; 7499 } 7500 7501 if (atLeastOneCompFail) 7502 return false; 7503 7504 TokIdx = I; // All of the tokens were handled, advance beyond all of them. 7505 return true; 7506} 7507 7508enum CXChildVisitResult AnnotateTokensWorker::Visit(CXCursor cursor, 7509 CXCursor parent) { 7510 SourceRange cursorRange = getRawCursorExtent(cursor); 7511 if (cursorRange.isInvalid()) 7512 return CXChildVisit_Recurse; 7513 7514 if (IsIgnoredChildCursor(cursor)) 7515 return CXChildVisit_Continue; 7516 7517 if (!HasContextSensitiveKeywords) { 7518 // Objective-C properties can have context-sensitive keywords. 7519 if (cursor.kind == CXCursor_ObjCPropertyDecl) { 7520 if (const ObjCPropertyDecl *Property = 7521 dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(cursor))) 7522 HasContextSensitiveKeywords = 7523 Property->getPropertyAttributesAsWritten() != 0; 7524 } 7525 // Objective-C methods can have context-sensitive keywords. 7526 else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl || 7527 cursor.kind == CXCursor_ObjCClassMethodDecl) { 7528 if (const ObjCMethodDecl *Method = 7529 dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) { 7530 if (Method->getObjCDeclQualifier()) 7531 HasContextSensitiveKeywords = true; 7532 else { 7533 for (const auto *P : Method->parameters()) { 7534 if (P->getObjCDeclQualifier()) { 7535 HasContextSensitiveKeywords = true; 7536 break; 7537 } 7538 } 7539 } 7540 } 7541 } 7542 // C++ methods can have context-sensitive keywords. 7543 else if (cursor.kind == CXCursor_CXXMethod) { 7544 if (const CXXMethodDecl *Method = 7545 dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(cursor))) { 7546 if (Method->hasAttr<FinalAttr>() || Method->hasAttr<OverrideAttr>()) 7547 HasContextSensitiveKeywords = true; 7548 } 7549 } 7550 // C++ classes can have context-sensitive keywords. 7551 else if (cursor.kind == CXCursor_StructDecl || 7552 cursor.kind == CXCursor_ClassDecl || 7553 cursor.kind == CXCursor_ClassTemplate || 7554 cursor.kind == CXCursor_ClassTemplatePartialSpecialization) { 7555 if (const Decl *D = getCursorDecl(cursor)) 7556 if (D->hasAttr<FinalAttr>()) 7557 HasContextSensitiveKeywords = true; 7558 } 7559 } 7560 7561 // Don't override a property annotation with its getter/setter method. 7562 if (cursor.kind == CXCursor_ObjCInstanceMethodDecl && 7563 parent.kind == CXCursor_ObjCPropertyDecl) 7564 return CXChildVisit_Continue; 7565 7566 if (clang_isPreprocessing(cursor.kind)) { 7567 // Items in the preprocessing record are kept separate from items in 7568 // declarations, so we keep a separate token index. 7569 unsigned SavedTokIdx = TokIdx; 7570 TokIdx = PreprocessingTokIdx; 7571 7572 // Skip tokens up until we catch up to the beginning of the preprocessing 7573 // entry. 7574 while (MoreTokens()) { 7575 const unsigned I = NextToken(); 7576 SourceLocation TokLoc = GetTokenLoc(I); 7577 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 7578 case RangeBefore: 7579 AdvanceToken(); 7580 continue; 7581 case RangeAfter: 7582 case RangeOverlap: 7583 break; 7584 } 7585 break; 7586 } 7587 7588 // Look at all of the tokens within this range. 7589 while (MoreTokens()) { 7590 const unsigned I = NextToken(); 7591 SourceLocation TokLoc = GetTokenLoc(I); 7592 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 7593 case RangeBefore: 7594 llvm_unreachable("Infeasible"); 7595 case RangeAfter: 7596 break; 7597 case RangeOverlap: 7598 // For macro expansions, just note where the beginning of the macro 7599 // expansion occurs. 7600 if (cursor.kind == CXCursor_MacroExpansion) { 7601 if (TokLoc == cursorRange.getBegin()) 7602 Cursors[I] = cursor; 7603 AdvanceToken(); 7604 break; 7605 } 7606 // We may have already annotated macro names inside macro definitions. 7607 if (Cursors[I].kind != CXCursor_MacroExpansion) 7608 Cursors[I] = cursor; 7609 AdvanceToken(); 7610 continue; 7611 } 7612 break; 7613 } 7614 7615 // Save the preprocessing token index; restore the non-preprocessing 7616 // token index. 7617 PreprocessingTokIdx = TokIdx; 7618 TokIdx = SavedTokIdx; 7619 return CXChildVisit_Recurse; 7620 } 7621 7622 if (cursorRange.isInvalid()) 7623 return CXChildVisit_Continue; 7624 7625 unsigned BeforeReachingCursorIdx = NextToken(); 7626 const enum CXCursorKind cursorK = clang_getCursorKind(cursor); 7627 const enum CXCursorKind K = clang_getCursorKind(parent); 7628 const CXCursor updateC = 7629 (clang_isInvalid(K) || K == CXCursor_TranslationUnit || 7630 // Attributes are annotated out-of-order, skip tokens until we reach it. 7631 clang_isAttribute(cursor.kind)) 7632 ? clang_getNullCursor() 7633 : parent; 7634 7635 annotateAndAdvanceTokens(updateC, RangeBefore, cursorRange); 7636 7637 // Avoid having the cursor of an expression "overwrite" the annotation of the 7638 // variable declaration that it belongs to. 7639 // This can happen for C++ constructor expressions whose range generally 7640 // include the variable declaration, e.g.: 7641 // MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor. 7642 if (clang_isExpression(cursorK) && MoreTokens()) { 7643 const Expr *E = getCursorExpr(cursor); 7644 if (const Decl *D = getCursorDecl(cursor)) { 7645 const unsigned I = NextToken(); 7646 if (E->getBeginLoc().isValid() && D->getLocation().isValid() && 7647 E->getBeginLoc() == D->getLocation() && 7648 E->getBeginLoc() == GetTokenLoc(I)) { 7649 updateCursorAnnotation(Cursors[I], updateC); 7650 AdvanceToken(); 7651 } 7652 } 7653 } 7654 7655 // Before recursing into the children keep some state that we are going 7656 // to use in the AnnotateTokensWorker::postVisitChildren callback to do some 7657 // extra work after the child nodes are visited. 7658 // Note that we don't call VisitChildren here to avoid traversing statements 7659 // code-recursively which can blow the stack. 7660 7661 PostChildrenInfo Info; 7662 Info.Cursor = cursor; 7663 Info.CursorRange = cursorRange; 7664 Info.BeforeReachingCursorIdx = BeforeReachingCursorIdx; 7665 Info.BeforeChildrenTokenIdx = NextToken(); 7666 Info.ChildActions = DetermineChildActions(cursor); 7667 PostChildrenInfos.push_back(Info); 7668 7669 return CXChildVisit_Recurse; 7670} 7671 7672bool AnnotateTokensWorker::postVisitChildren(CXCursor cursor) { 7673 if (PostChildrenInfos.empty()) 7674 return false; 7675 const PostChildrenInfo &Info = PostChildrenInfos.back(); 7676 if (!clang_equalCursors(Info.Cursor, cursor)) 7677 return false; 7678 7679 HandlePostPonedChildCursors(Info); 7680 7681 const unsigned BeforeChildren = Info.BeforeChildrenTokenIdx; 7682 const unsigned AfterChildren = NextToken(); 7683 SourceRange cursorRange = Info.CursorRange; 7684 7685 // Scan the tokens that are at the end of the cursor, but are not captured 7686 // but the child cursors. 7687 annotateAndAdvanceTokens(cursor, RangeOverlap, cursorRange); 7688 7689 // Scan the tokens that are at the beginning of the cursor, but are not 7690 // capture by the child cursors. 7691 for (unsigned I = BeforeChildren; I != AfterChildren; ++I) { 7692 if (!clang_isInvalid(clang_getCursorKind(Cursors[I]))) 7693 break; 7694 7695 Cursors[I] = cursor; 7696 } 7697 7698 // Attributes are annotated out-of-order, rewind TokIdx to when we first 7699 // encountered the attribute cursor. 7700 if (clang_isAttribute(cursor.kind)) 7701 TokIdx = Info.BeforeReachingCursorIdx; 7702 7703 PostChildrenInfos.pop_back(); 7704 return false; 7705} 7706 7707void AnnotateTokensWorker::HandlePostPonedChildCursors( 7708 const PostChildrenInfo &Info) { 7709 for (const auto &ChildAction : Info.ChildActions) { 7710 if (ChildAction.action == PostChildrenAction::Postpone) { 7711 HandlePostPonedChildCursor(ChildAction.cursor, 7712 Info.BeforeChildrenTokenIdx); 7713 } 7714 } 7715} 7716 7717void AnnotateTokensWorker::HandlePostPonedChildCursor( 7718 CXCursor Cursor, unsigned StartTokenIndex) { 7719 unsigned I = StartTokenIndex; 7720 7721 // The bracket tokens of a Call or Subscript operator are mapped to 7722 // CallExpr/CXXOperatorCallExpr because we skipped visiting the corresponding 7723 // DeclRefExpr. Remap these tokens to the DeclRefExpr cursors. 7724 for (unsigned RefNameRangeNr = 0; I < NumTokens; RefNameRangeNr++) { 7725 const CXSourceRange CXRefNameRange = clang_getCursorReferenceNameRange( 7726 Cursor, CXNameRange_WantQualifier, RefNameRangeNr); 7727 if (clang_Range_isNull(CXRefNameRange)) 7728 break; // All ranges handled. 7729 7730 SourceRange RefNameRange = cxloc::translateCXSourceRange(CXRefNameRange); 7731 while (I < NumTokens) { 7732 const SourceLocation TokenLocation = GetTokenLoc(I); 7733 if (!TokenLocation.isValid()) 7734 break; 7735 7736 // Adapt the end range, because LocationCompare() reports 7737 // RangeOverlap even for the not-inclusive end location. 7738 const SourceLocation fixedEnd = 7739 RefNameRange.getEnd().getLocWithOffset(-1); 7740 RefNameRange = SourceRange(RefNameRange.getBegin(), fixedEnd); 7741 7742 const RangeComparisonResult ComparisonResult = 7743 LocationCompare(SrcMgr, TokenLocation, RefNameRange); 7744 7745 if (ComparisonResult == RangeOverlap) { 7746 Cursors[I++] = Cursor; 7747 } else if (ComparisonResult == RangeBefore) { 7748 ++I; // Not relevant token, check next one. 7749 } else if (ComparisonResult == RangeAfter) { 7750 break; // All tokens updated for current range, check next. 7751 } 7752 } 7753 } 7754} 7755 7756static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 7757 CXCursor parent, 7758 CXClientData client_data) { 7759 return static_cast<AnnotateTokensWorker *>(client_data) 7760 ->Visit(cursor, parent); 7761} 7762 7763static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor, 7764 CXClientData client_data) { 7765 return static_cast<AnnotateTokensWorker *>(client_data) 7766 ->postVisitChildren(cursor); 7767} 7768 7769namespace { 7770 7771/// Uses the macro expansions in the preprocessing record to find 7772/// and mark tokens that are macro arguments. This info is used by the 7773/// AnnotateTokensWorker. 7774class MarkMacroArgTokensVisitor { 7775 SourceManager &SM; 7776 CXToken *Tokens; 7777 unsigned NumTokens; 7778 unsigned CurIdx; 7779 7780public: 7781 MarkMacroArgTokensVisitor(SourceManager &SM, CXToken *tokens, 7782 unsigned numTokens) 7783 : SM(SM), Tokens(tokens), NumTokens(numTokens), CurIdx(0) {} 7784 7785 CXChildVisitResult visit(CXCursor cursor, CXCursor parent) { 7786 if (cursor.kind != CXCursor_MacroExpansion) 7787 return CXChildVisit_Continue; 7788 7789 SourceRange macroRange = getCursorMacroExpansion(cursor).getSourceRange(); 7790 if (macroRange.getBegin() == macroRange.getEnd()) 7791 return CXChildVisit_Continue; // it's not a function macro. 7792 7793 for (; CurIdx < NumTokens; ++CurIdx) { 7794 if (!SM.isBeforeInTranslationUnit(getTokenLoc(CurIdx), 7795 macroRange.getBegin())) 7796 break; 7797 } 7798 7799 if (CurIdx == NumTokens) 7800 return CXChildVisit_Break; 7801 7802 for (; CurIdx < NumTokens; ++CurIdx) { 7803 SourceLocation tokLoc = getTokenLoc(CurIdx); 7804 if (!SM.isBeforeInTranslationUnit(tokLoc, macroRange.getEnd())) 7805 break; 7806 7807 setFunctionMacroTokenLoc(CurIdx, SM.getMacroArgExpandedLocation(tokLoc)); 7808 } 7809 7810 if (CurIdx == NumTokens) 7811 return CXChildVisit_Break; 7812 7813 return CXChildVisit_Continue; 7814 } 7815 7816private: 7817 CXToken &getTok(unsigned Idx) { 7818 assert(Idx < NumTokens); 7819 return Tokens[Idx]; 7820 } 7821 const CXToken &getTok(unsigned Idx) const { 7822 assert(Idx < NumTokens); 7823 return Tokens[Idx]; 7824 } 7825 7826 SourceLocation getTokenLoc(unsigned tokI) { 7827 return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]); 7828 } 7829 7830 void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) { 7831 // The third field is reserved and currently not used. Use it here 7832 // to mark macro arg expanded tokens with their expanded locations. 7833 getTok(tokI).int_data[3] = loc.getRawEncoding(); 7834 } 7835}; 7836 7837} // end anonymous namespace 7838 7839static CXChildVisitResult 7840MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent, 7841 CXClientData client_data) { 7842 return static_cast<MarkMacroArgTokensVisitor *>(client_data) 7843 ->visit(cursor, parent); 7844} 7845 7846/// Used by \c annotatePreprocessorTokens. 7847/// \returns true if lexing was finished, false otherwise. 7848static bool lexNext(Lexer &Lex, Token &Tok, unsigned &NextIdx, 7849 unsigned NumTokens) { 7850 if (NextIdx >= NumTokens) 7851 return true; 7852 7853 ++NextIdx; 7854 Lex.LexFromRawLexer(Tok); 7855 return Tok.is(tok::eof); 7856} 7857 7858static void annotatePreprocessorTokens(CXTranslationUnit TU, 7859 SourceRange RegionOfInterest, 7860 CXCursor *Cursors, CXToken *Tokens, 7861 unsigned NumTokens) { 7862 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 7863 7864 Preprocessor &PP = CXXUnit->getPreprocessor(); 7865 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 7866 std::pair<FileID, unsigned> BeginLocInfo = 7867 SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getBegin()); 7868 std::pair<FileID, unsigned> EndLocInfo = 7869 SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getEnd()); 7870 7871 if (BeginLocInfo.first != EndLocInfo.first) 7872 return; 7873 7874 StringRef Buffer; 7875 bool Invalid = false; 7876 Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid); 7877 if (Buffer.empty() || Invalid) 7878 return; 7879 7880 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 7881 CXXUnit->getASTContext().getLangOpts(), Buffer.begin(), 7882 Buffer.data() + BeginLocInfo.second, Buffer.end()); 7883 Lex.SetCommentRetentionState(true); 7884 7885 unsigned NextIdx = 0; 7886 // Lex tokens in raw mode until we hit the end of the range, to avoid 7887 // entering #includes or expanding macros. 7888 while (true) { 7889 Token Tok; 7890 if (lexNext(Lex, Tok, NextIdx, NumTokens)) 7891 break; 7892 unsigned TokIdx = NextIdx - 1; 7893 assert(Tok.getLocation() == 7894 SourceLocation::getFromRawEncoding(Tokens[TokIdx].int_data[1])); 7895 7896 reprocess: 7897 if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) { 7898 // We have found a preprocessing directive. Annotate the tokens 7899 // appropriately. 7900 // 7901 // FIXME: Some simple tests here could identify macro definitions and 7902 // #undefs, to provide specific cursor kinds for those. 7903 7904 SourceLocation BeginLoc = Tok.getLocation(); 7905 if (lexNext(Lex, Tok, NextIdx, NumTokens)) 7906 break; 7907 7908 MacroInfo *MI = nullptr; 7909 if (Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == "define") { 7910 if (lexNext(Lex, Tok, NextIdx, NumTokens)) 7911 break; 7912 7913 if (Tok.is(tok::raw_identifier)) { 7914 IdentifierInfo &II = 7915 PP.getIdentifierTable().get(Tok.getRawIdentifier()); 7916 SourceLocation MappedTokLoc = 7917 CXXUnit->mapLocationToPreamble(Tok.getLocation()); 7918 MI = getMacroInfo(II, MappedTokLoc, TU); 7919 } 7920 } 7921 7922 bool finished = false; 7923 do { 7924 if (lexNext(Lex, Tok, NextIdx, NumTokens)) { 7925 finished = true; 7926 break; 7927 } 7928 // If we are in a macro definition, check if the token was ever a 7929 // macro name and annotate it if that's the case. 7930 if (MI) { 7931 SourceLocation SaveLoc = Tok.getLocation(); 7932 Tok.setLocation(CXXUnit->mapLocationToPreamble(SaveLoc)); 7933 MacroDefinitionRecord *MacroDef = 7934 checkForMacroInMacroDefinition(MI, Tok, TU); 7935 Tok.setLocation(SaveLoc); 7936 if (MacroDef) 7937 Cursors[NextIdx - 1] = 7938 MakeMacroExpansionCursor(MacroDef, Tok.getLocation(), TU); 7939 } 7940 } while (!Tok.isAtStartOfLine()); 7941 7942 unsigned LastIdx = finished ? NextIdx - 1 : NextIdx - 2; 7943 assert(TokIdx <= LastIdx); 7944 SourceLocation EndLoc = 7945 SourceLocation::getFromRawEncoding(Tokens[LastIdx].int_data[1]); 7946 CXCursor Cursor = 7947 MakePreprocessingDirectiveCursor(SourceRange(BeginLoc, EndLoc), TU); 7948 7949 for (; TokIdx <= LastIdx; ++TokIdx) 7950 updateCursorAnnotation(Cursors[TokIdx], Cursor); 7951 7952 if (finished) 7953 break; 7954 goto reprocess; 7955 } 7956 } 7957} 7958 7959// This gets run a separate thread to avoid stack blowout. 7960static void clang_annotateTokensImpl(CXTranslationUnit TU, ASTUnit *CXXUnit, 7961 CXToken *Tokens, unsigned NumTokens, 7962 CXCursor *Cursors) { 7963 CIndexer *CXXIdx = TU->CIdx; 7964 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 7965 setThreadBackgroundPriority(); 7966 7967 // Determine the region of interest, which contains all of the tokens. 7968 SourceRange RegionOfInterest; 7969 RegionOfInterest.setBegin( 7970 cxloc::translateSourceLocation(clang_getTokenLocation(TU, Tokens[0]))); 7971 RegionOfInterest.setEnd(cxloc::translateSourceLocation( 7972 clang_getTokenLocation(TU, Tokens[NumTokens - 1]))); 7973 7974 // Relex the tokens within the source range to look for preprocessing 7975 // directives. 7976 annotatePreprocessorTokens(TU, RegionOfInterest, Cursors, Tokens, NumTokens); 7977 7978 // If begin location points inside a macro argument, set it to the expansion 7979 // location so we can have the full context when annotating semantically. 7980 { 7981 SourceManager &SM = CXXUnit->getSourceManager(); 7982 SourceLocation Loc = 7983 SM.getMacroArgExpandedLocation(RegionOfInterest.getBegin()); 7984 if (Loc.isMacroID()) 7985 RegionOfInterest.setBegin(SM.getExpansionLoc(Loc)); 7986 } 7987 7988 if (CXXUnit->getPreprocessor().getPreprocessingRecord()) { 7989 // Search and mark tokens that are macro argument expansions. 7990 MarkMacroArgTokensVisitor Visitor(CXXUnit->getSourceManager(), Tokens, 7991 NumTokens); 7992 CursorVisitor MacroArgMarker( 7993 TU, MarkMacroArgTokensVisitorDelegate, &Visitor, 7994 /*VisitPreprocessorLast=*/true, 7995 /*VisitIncludedEntities=*/false, RegionOfInterest); 7996 MacroArgMarker.visitPreprocessedEntitiesInRegion(); 7997 } 7998 7999 // Annotate all of the source locations in the region of interest that map to 8000 // a specific cursor. 8001 AnnotateTokensWorker W(Tokens, Cursors, NumTokens, TU, RegionOfInterest); 8002 8003 // FIXME: We use a ridiculous stack size here because the data-recursion 8004 // algorithm uses a large stack frame than the non-data recursive version, 8005 // and AnnotationTokensWorker currently transforms the data-recursion 8006 // algorithm back into a traditional recursion by explicitly calling 8007 // VisitChildren(). We will need to remove this explicit recursive call. 8008 W.AnnotateTokens(); 8009 8010 // If we ran into any entities that involve context-sensitive keywords, 8011 // take another pass through the tokens to mark them as such. 8012 if (W.hasContextSensitiveKeywords()) { 8013 for (unsigned I = 0; I != NumTokens; ++I) { 8014 if (clang_getTokenKind(Tokens[I]) != CXToken_Identifier) 8015 continue; 8016 8017 if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) { 8018 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 8019 if (const ObjCPropertyDecl *Property = 8020 dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(Cursors[I]))) { 8021 if (Property->getPropertyAttributesAsWritten() != 0 && 8022 llvm::StringSwitch<bool>(II->getName()) 8023 .Case("readonly", true) 8024 .Case("assign", true) 8025 .Case("unsafe_unretained", true) 8026 .Case("readwrite", true) 8027 .Case("retain", true) 8028 .Case("copy", true) 8029 .Case("nonatomic", true) 8030 .Case("atomic", true) 8031 .Case("getter", true) 8032 .Case("setter", true) 8033 .Case("strong", true) 8034 .Case("weak", true) 8035 .Case("class", true) 8036 .Default(false)) 8037 Tokens[I].int_data[0] = CXToken_Keyword; 8038 } 8039 continue; 8040 } 8041 8042 if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl || 8043 Cursors[I].kind == CXCursor_ObjCClassMethodDecl) { 8044 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 8045 if (llvm::StringSwitch<bool>(II->getName()) 8046 .Case("in", true) 8047 .Case("out", true) 8048 .Case("inout", true) 8049 .Case("oneway", true) 8050 .Case("bycopy", true) 8051 .Case("byref", true) 8052 .Default(false)) 8053 Tokens[I].int_data[0] = CXToken_Keyword; 8054 continue; 8055 } 8056 8057 if (Cursors[I].kind == CXCursor_CXXFinalAttr || 8058 Cursors[I].kind == CXCursor_CXXOverrideAttr) { 8059 Tokens[I].int_data[0] = CXToken_Keyword; 8060 continue; 8061 } 8062 } 8063 } 8064} 8065 8066void clang_annotateTokens(CXTranslationUnit TU, CXToken *Tokens, 8067 unsigned NumTokens, CXCursor *Cursors) { 8068 if (isNotUsableTU(TU)) { 8069 LOG_BAD_TU(TU); 8070 return; 8071 } 8072 if (NumTokens == 0 || !Tokens || !Cursors) { 8073 LOG_FUNC_SECTION { *Log << "<null input>"; } 8074 return; 8075 } 8076 8077 LOG_FUNC_SECTION { 8078 *Log << TU << ' '; 8079 CXSourceLocation bloc = clang_getTokenLocation(TU, Tokens[0]); 8080 CXSourceLocation eloc = clang_getTokenLocation(TU, Tokens[NumTokens - 1]); 8081 *Log << clang_getRange(bloc, eloc); 8082 } 8083 8084 // Any token we don't specifically annotate will have a NULL cursor. 8085 CXCursor C = clang_getNullCursor(); 8086 for (unsigned I = 0; I != NumTokens; ++I) 8087 Cursors[I] = C; 8088 8089 ASTUnit *CXXUnit = cxtu::getASTUnit(TU); 8090 if (!CXXUnit) 8091 return; 8092 8093 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 8094 8095 auto AnnotateTokensImpl = [=]() { 8096 clang_annotateTokensImpl(TU, CXXUnit, Tokens, NumTokens, Cursors); 8097 }; 8098 llvm::CrashRecoveryContext CRC; 8099 if (!RunSafely(CRC, AnnotateTokensImpl, GetSafetyThreadStackSize() * 2)) { 8100 fprintf(stderr, "libclang: crash detected while annotating tokens\n"); 8101 } 8102} 8103 8104//===----------------------------------------------------------------------===// 8105// Operations for querying linkage of a cursor. 8106//===----------------------------------------------------------------------===// 8107 8108CXLinkageKind clang_getCursorLinkage(CXCursor cursor) { 8109 if (!clang_isDeclaration(cursor.kind)) 8110 return CXLinkage_Invalid; 8111 8112 const Decl *D = cxcursor::getCursorDecl(cursor); 8113 if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D)) 8114 switch (ND->getLinkageInternal()) { 8115 case NoLinkage: 8116 case VisibleNoLinkage: 8117 return CXLinkage_NoLinkage; 8118 case ModuleInternalLinkage: 8119 case InternalLinkage: 8120 return CXLinkage_Internal; 8121 case UniqueExternalLinkage: 8122 return CXLinkage_UniqueExternal; 8123 case ModuleLinkage: 8124 case ExternalLinkage: 8125 return CXLinkage_External; 8126 }; 8127 8128 return CXLinkage_Invalid; 8129} 8130 8131//===----------------------------------------------------------------------===// 8132// Operations for querying visibility of a cursor. 8133//===----------------------------------------------------------------------===// 8134 8135CXVisibilityKind clang_getCursorVisibility(CXCursor cursor) { 8136 if (!clang_isDeclaration(cursor.kind)) 8137 return CXVisibility_Invalid; 8138 8139 const Decl *D = cxcursor::getCursorDecl(cursor); 8140 if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D)) 8141 switch (ND->getVisibility()) { 8142 case HiddenVisibility: 8143 return CXVisibility_Hidden; 8144 case ProtectedVisibility: 8145 return CXVisibility_Protected; 8146 case DefaultVisibility: 8147 return CXVisibility_Default; 8148 }; 8149 8150 return CXVisibility_Invalid; 8151} 8152 8153//===----------------------------------------------------------------------===// 8154// Operations for querying language of a cursor. 8155//===----------------------------------------------------------------------===// 8156 8157static CXLanguageKind getDeclLanguage(const Decl *D) { 8158 if (!D) 8159 return CXLanguage_C; 8160 8161 switch (D->getKind()) { 8162 default: 8163 break; 8164 case Decl::ImplicitParam: 8165 case Decl::ObjCAtDefsField: 8166 case Decl::ObjCCategory: 8167 case Decl::ObjCCategoryImpl: 8168 case Decl::ObjCCompatibleAlias: 8169 case Decl::ObjCImplementation: 8170 case Decl::ObjCInterface: 8171 case Decl::ObjCIvar: 8172 case Decl::ObjCMethod: 8173 case Decl::ObjCProperty: 8174 case Decl::ObjCPropertyImpl: 8175 case Decl::ObjCProtocol: 8176 case Decl::ObjCTypeParam: 8177 return CXLanguage_ObjC; 8178 case Decl::CXXConstructor: 8179 case Decl::CXXConversion: 8180 case Decl::CXXDestructor: 8181 case Decl::CXXMethod: 8182 case Decl::CXXRecord: 8183 case Decl::ClassTemplate: 8184 case Decl::ClassTemplatePartialSpecialization: 8185 case Decl::ClassTemplateSpecialization: 8186 case Decl::Friend: 8187 case Decl::FriendTemplate: 8188 case Decl::FunctionTemplate: 8189 case Decl::LinkageSpec: 8190 case Decl::Namespace: 8191 case Decl::NamespaceAlias: 8192 case Decl::NonTypeTemplateParm: 8193 case Decl::StaticAssert: 8194 case Decl::TemplateTemplateParm: 8195 case Decl::TemplateTypeParm: 8196 case Decl::UnresolvedUsingTypename: 8197 case Decl::UnresolvedUsingValue: 8198 case Decl::Using: 8199 case Decl::UsingDirective: 8200 case Decl::UsingShadow: 8201 return CXLanguage_CPlusPlus; 8202 } 8203 8204 return CXLanguage_C; 8205} 8206 8207static CXAvailabilityKind getCursorAvailabilityForDecl(const Decl *D) { 8208 if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted()) 8209 return CXAvailability_NotAvailable; 8210 8211 switch (D->getAvailability()) { 8212 case AR_Available: 8213 case AR_NotYetIntroduced: 8214 if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D)) 8215 return getCursorAvailabilityForDecl( 8216 cast<Decl>(EnumConst->getDeclContext())); 8217 return CXAvailability_Available; 8218 8219 case AR_Deprecated: 8220 return CXAvailability_Deprecated; 8221 8222 case AR_Unavailable: 8223 return CXAvailability_NotAvailable; 8224 } 8225 8226 llvm_unreachable("Unknown availability kind!"); 8227} 8228 8229enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) { 8230 if (clang_isDeclaration(cursor.kind)) 8231 if (const Decl *D = cxcursor::getCursorDecl(cursor)) 8232 return getCursorAvailabilityForDecl(D); 8233 8234 return CXAvailability_Available; 8235} 8236 8237static CXVersion convertVersion(VersionTuple In) { 8238 CXVersion Out = {-1, -1, -1}; 8239 if (In.empty()) 8240 return Out; 8241 8242 Out.Major = In.getMajor(); 8243 8244 std::optional<unsigned> Minor = In.getMinor(); 8245 if (Minor) 8246 Out.Minor = *Minor; 8247 else 8248 return Out; 8249 8250 std::optional<unsigned> Subminor = In.getSubminor(); 8251 if (Subminor) 8252 Out.Subminor = *Subminor; 8253 8254 return Out; 8255} 8256 8257static void getCursorPlatformAvailabilityForDecl( 8258 const Decl *D, int *always_deprecated, CXString *deprecated_message, 8259 int *always_unavailable, CXString *unavailable_message, 8260 SmallVectorImpl<AvailabilityAttr *> &AvailabilityAttrs) { 8261 bool HadAvailAttr = false; 8262 for (auto A : D->attrs()) { 8263 if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(A)) { 8264 HadAvailAttr = true; 8265 if (always_deprecated) 8266 *always_deprecated = 1; 8267 if (deprecated_message) { 8268 clang_disposeString(*deprecated_message); 8269 *deprecated_message = cxstring::createDup(Deprecated->getMessage()); 8270 } 8271 continue; 8272 } 8273 8274 if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(A)) { 8275 HadAvailAttr = true; 8276 if (always_unavailable) 8277 *always_unavailable = 1; 8278 if (unavailable_message) { 8279 clang_disposeString(*unavailable_message); 8280 *unavailable_message = cxstring::createDup(Unavailable->getMessage()); 8281 } 8282 continue; 8283 } 8284 8285 if (AvailabilityAttr *Avail = dyn_cast<AvailabilityAttr>(A)) { 8286 AvailabilityAttrs.push_back(Avail); 8287 HadAvailAttr = true; 8288 } 8289 } 8290 8291 if (!HadAvailAttr) 8292 if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D)) 8293 return getCursorPlatformAvailabilityForDecl( 8294 cast<Decl>(EnumConst->getDeclContext()), always_deprecated, 8295 deprecated_message, always_unavailable, unavailable_message, 8296 AvailabilityAttrs); 8297 8298 // If no availability attributes are found, inherit the attribute from the 8299 // containing decl or the class or category interface decl. 8300 if (AvailabilityAttrs.empty()) { 8301 const ObjCContainerDecl *CD = nullptr; 8302 const DeclContext *DC = D->getDeclContext(); 8303 8304 if (auto *IMD = dyn_cast<ObjCImplementationDecl>(D)) 8305 CD = IMD->getClassInterface(); 8306 else if (auto *CatD = dyn_cast<ObjCCategoryDecl>(D)) 8307 CD = CatD->getClassInterface(); 8308 else if (auto *IMD = dyn_cast<ObjCCategoryImplDecl>(D)) 8309 CD = IMD->getCategoryDecl(); 8310 else if (auto *ID = dyn_cast<ObjCInterfaceDecl>(DC)) 8311 CD = ID; 8312 else if (auto *CatD = dyn_cast<ObjCCategoryDecl>(DC)) 8313 CD = CatD; 8314 else if (auto *IMD = dyn_cast<ObjCImplementationDecl>(DC)) 8315 CD = IMD->getClassInterface(); 8316 else if (auto *IMD = dyn_cast<ObjCCategoryImplDecl>(DC)) 8317 CD = IMD->getCategoryDecl(); 8318 else if (auto *PD = dyn_cast<ObjCProtocolDecl>(DC)) 8319 CD = PD; 8320 8321 if (CD) 8322 getCursorPlatformAvailabilityForDecl( 8323 CD, always_deprecated, deprecated_message, always_unavailable, 8324 unavailable_message, AvailabilityAttrs); 8325 return; 8326 } 8327 8328 llvm::sort( 8329 AvailabilityAttrs, [](AvailabilityAttr *LHS, AvailabilityAttr *RHS) { 8330 return LHS->getPlatform()->getName() < RHS->getPlatform()->getName(); 8331 }); 8332 ASTContext &Ctx = D->getASTContext(); 8333 auto It = std::unique( 8334 AvailabilityAttrs.begin(), AvailabilityAttrs.end(), 8335 [&Ctx](AvailabilityAttr *LHS, AvailabilityAttr *RHS) { 8336 if (LHS->getPlatform() != RHS->getPlatform()) 8337 return false; 8338 8339 if (LHS->getIntroduced() == RHS->getIntroduced() && 8340 LHS->getDeprecated() == RHS->getDeprecated() && 8341 LHS->getObsoleted() == RHS->getObsoleted() && 8342 LHS->getMessage() == RHS->getMessage() && 8343 LHS->getReplacement() == RHS->getReplacement()) 8344 return true; 8345 8346 if ((!LHS->getIntroduced().empty() && !RHS->getIntroduced().empty()) || 8347 (!LHS->getDeprecated().empty() && !RHS->getDeprecated().empty()) || 8348 (!LHS->getObsoleted().empty() && !RHS->getObsoleted().empty())) 8349 return false; 8350 8351 if (LHS->getIntroduced().empty() && !RHS->getIntroduced().empty()) 8352 LHS->setIntroduced(Ctx, RHS->getIntroduced()); 8353 8354 if (LHS->getDeprecated().empty() && !RHS->getDeprecated().empty()) { 8355 LHS->setDeprecated(Ctx, RHS->getDeprecated()); 8356 if (LHS->getMessage().empty()) 8357 LHS->setMessage(Ctx, RHS->getMessage()); 8358 if (LHS->getReplacement().empty()) 8359 LHS->setReplacement(Ctx, RHS->getReplacement()); 8360 } 8361 8362 if (LHS->getObsoleted().empty() && !RHS->getObsoleted().empty()) { 8363 LHS->setObsoleted(Ctx, RHS->getObsoleted()); 8364 if (LHS->getMessage().empty()) 8365 LHS->setMessage(Ctx, RHS->getMessage()); 8366 if (LHS->getReplacement().empty()) 8367 LHS->setReplacement(Ctx, RHS->getReplacement()); 8368 } 8369 8370 return true; 8371 }); 8372 AvailabilityAttrs.erase(It, AvailabilityAttrs.end()); 8373} 8374 8375int clang_getCursorPlatformAvailability(CXCursor cursor, int *always_deprecated, 8376 CXString *deprecated_message, 8377 int *always_unavailable, 8378 CXString *unavailable_message, 8379 CXPlatformAvailability *availability, 8380 int availability_size) { 8381 if (always_deprecated) 8382 *always_deprecated = 0; 8383 if (deprecated_message) 8384 *deprecated_message = cxstring::createEmpty(); 8385 if (always_unavailable) 8386 *always_unavailable = 0; 8387 if (unavailable_message) 8388 *unavailable_message = cxstring::createEmpty(); 8389 8390 if (!clang_isDeclaration(cursor.kind)) 8391 return 0; 8392 8393 const Decl *D = cxcursor::getCursorDecl(cursor); 8394 if (!D) 8395 return 0; 8396 8397 SmallVector<AvailabilityAttr *, 8> AvailabilityAttrs; 8398 getCursorPlatformAvailabilityForDecl(D, always_deprecated, deprecated_message, 8399 always_unavailable, unavailable_message, 8400 AvailabilityAttrs); 8401 for (const auto &Avail : llvm::enumerate( 8402 llvm::ArrayRef(AvailabilityAttrs).take_front(availability_size))) { 8403 availability[Avail.index()].Platform = 8404 cxstring::createDup(Avail.value()->getPlatform()->getName()); 8405 availability[Avail.index()].Introduced = 8406 convertVersion(Avail.value()->getIntroduced()); 8407 availability[Avail.index()].Deprecated = 8408 convertVersion(Avail.value()->getDeprecated()); 8409 availability[Avail.index()].Obsoleted = 8410 convertVersion(Avail.value()->getObsoleted()); 8411 availability[Avail.index()].Unavailable = Avail.value()->getUnavailable(); 8412 availability[Avail.index()].Message = 8413 cxstring::createDup(Avail.value()->getMessage()); 8414 } 8415 8416 return AvailabilityAttrs.size(); 8417} 8418 8419void clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability) { 8420 clang_disposeString(availability->Platform); 8421 clang_disposeString(availability->Message); 8422} 8423 8424CXLanguageKind clang_getCursorLanguage(CXCursor cursor) { 8425 if (clang_isDeclaration(cursor.kind)) 8426 return getDeclLanguage(cxcursor::getCursorDecl(cursor)); 8427 8428 return CXLanguage_Invalid; 8429} 8430 8431CXTLSKind clang_getCursorTLSKind(CXCursor cursor) { 8432 const Decl *D = cxcursor::getCursorDecl(cursor); 8433 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 8434 switch (VD->getTLSKind()) { 8435 case VarDecl::TLS_None: 8436 return CXTLS_None; 8437 case VarDecl::TLS_Dynamic: 8438 return CXTLS_Dynamic; 8439 case VarDecl::TLS_Static: 8440 return CXTLS_Static; 8441 } 8442 } 8443 8444 return CXTLS_None; 8445} 8446 8447/// If the given cursor is the "templated" declaration 8448/// describing a class or function template, return the class or 8449/// function template. 8450static const Decl *maybeGetTemplateCursor(const Decl *D) { 8451 if (!D) 8452 return nullptr; 8453 8454 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 8455 if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate()) 8456 return FunTmpl; 8457 8458 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) 8459 if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate()) 8460 return ClassTmpl; 8461 8462 return D; 8463} 8464 8465enum CX_StorageClass clang_Cursor_getStorageClass(CXCursor C) { 8466 StorageClass sc = SC_None; 8467 const Decl *D = getCursorDecl(C); 8468 if (D) { 8469 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 8470 sc = FD->getStorageClass(); 8471 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 8472 sc = VD->getStorageClass(); 8473 } else { 8474 return CX_SC_Invalid; 8475 } 8476 } else { 8477 return CX_SC_Invalid; 8478 } 8479 switch (sc) { 8480 case SC_None: 8481 return CX_SC_None; 8482 case SC_Extern: 8483 return CX_SC_Extern; 8484 case SC_Static: 8485 return CX_SC_Static; 8486 case SC_PrivateExtern: 8487 return CX_SC_PrivateExtern; 8488 case SC_Auto: 8489 return CX_SC_Auto; 8490 case SC_Register: 8491 return CX_SC_Register; 8492 } 8493 llvm_unreachable("Unhandled storage class!"); 8494} 8495 8496CXCursor clang_getCursorSemanticParent(CXCursor cursor) { 8497 if (clang_isDeclaration(cursor.kind)) { 8498 if (const Decl *D = getCursorDecl(cursor)) { 8499 const DeclContext *DC = D->getDeclContext(); 8500 if (!DC) 8501 return clang_getNullCursor(); 8502 8503 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 8504 getCursorTU(cursor)); 8505 } 8506 } 8507 8508 if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) { 8509 if (const Decl *D = getCursorDecl(cursor)) 8510 return MakeCXCursor(D, getCursorTU(cursor)); 8511 } 8512 8513 return clang_getNullCursor(); 8514} 8515 8516CXCursor clang_getCursorLexicalParent(CXCursor cursor) { 8517 if (clang_isDeclaration(cursor.kind)) { 8518 if (const Decl *D = getCursorDecl(cursor)) { 8519 const DeclContext *DC = D->getLexicalDeclContext(); 8520 if (!DC) 8521 return clang_getNullCursor(); 8522 8523 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 8524 getCursorTU(cursor)); 8525 } 8526 } 8527 8528 // FIXME: Note that we can't easily compute the lexical context of a 8529 // statement or expression, so we return nothing. 8530 return clang_getNullCursor(); 8531} 8532 8533CXFile clang_getIncludedFile(CXCursor cursor) { 8534 if (cursor.kind != CXCursor_InclusionDirective) 8535 return nullptr; 8536 8537 const InclusionDirective *ID = getCursorInclusionDirective(cursor); 8538 OptionalFileEntryRef File = ID->getFile(); 8539 return const_cast<FileEntry *>(File ? &File->getFileEntry() : nullptr); 8540} 8541 8542unsigned clang_Cursor_getObjCPropertyAttributes(CXCursor C, unsigned reserved) { 8543 if (C.kind != CXCursor_ObjCPropertyDecl) 8544 return CXObjCPropertyAttr_noattr; 8545 8546 unsigned Result = CXObjCPropertyAttr_noattr; 8547 const auto *PD = cast<ObjCPropertyDecl>(getCursorDecl(C)); 8548 ObjCPropertyAttribute::Kind Attr = PD->getPropertyAttributesAsWritten(); 8549 8550#define SET_CXOBJCPROP_ATTR(A) \ 8551 if (Attr & ObjCPropertyAttribute::kind_##A) \ 8552 Result |= CXObjCPropertyAttr_##A 8553 SET_CXOBJCPROP_ATTR(readonly); 8554 SET_CXOBJCPROP_ATTR(getter); 8555 SET_CXOBJCPROP_ATTR(assign); 8556 SET_CXOBJCPROP_ATTR(readwrite); 8557 SET_CXOBJCPROP_ATTR(retain); 8558 SET_CXOBJCPROP_ATTR(copy); 8559 SET_CXOBJCPROP_ATTR(nonatomic); 8560 SET_CXOBJCPROP_ATTR(setter); 8561 SET_CXOBJCPROP_ATTR(atomic); 8562 SET_CXOBJCPROP_ATTR(weak); 8563 SET_CXOBJCPROP_ATTR(strong); 8564 SET_CXOBJCPROP_ATTR(unsafe_unretained); 8565 SET_CXOBJCPROP_ATTR(class); 8566#undef SET_CXOBJCPROP_ATTR 8567 8568 return Result; 8569} 8570 8571CXString clang_Cursor_getObjCPropertyGetterName(CXCursor C) { 8572 if (C.kind != CXCursor_ObjCPropertyDecl) 8573 return cxstring::createNull(); 8574 8575 const auto *PD = cast<ObjCPropertyDecl>(getCursorDecl(C)); 8576 Selector sel = PD->getGetterName(); 8577 if (sel.isNull()) 8578 return cxstring::createNull(); 8579 8580 return cxstring::createDup(sel.getAsString()); 8581} 8582 8583CXString clang_Cursor_getObjCPropertySetterName(CXCursor C) { 8584 if (C.kind != CXCursor_ObjCPropertyDecl) 8585 return cxstring::createNull(); 8586 8587 const auto *PD = cast<ObjCPropertyDecl>(getCursorDecl(C)); 8588 Selector sel = PD->getSetterName(); 8589 if (sel.isNull()) 8590 return cxstring::createNull(); 8591 8592 return cxstring::createDup(sel.getAsString()); 8593} 8594 8595unsigned clang_Cursor_getObjCDeclQualifiers(CXCursor C) { 8596 if (!clang_isDeclaration(C.kind)) 8597 return CXObjCDeclQualifier_None; 8598 8599 Decl::ObjCDeclQualifier QT = Decl::OBJC_TQ_None; 8600 const Decl *D = getCursorDecl(C); 8601 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 8602 QT = MD->getObjCDeclQualifier(); 8603 else if (const ParmVarDecl *PD = dyn_cast<ParmVarDecl>(D)) 8604 QT = PD->getObjCDeclQualifier(); 8605 if (QT == Decl::OBJC_TQ_None) 8606 return CXObjCDeclQualifier_None; 8607 8608 unsigned Result = CXObjCDeclQualifier_None; 8609 if (QT & Decl::OBJC_TQ_In) 8610 Result |= CXObjCDeclQualifier_In; 8611 if (QT & Decl::OBJC_TQ_Inout) 8612 Result |= CXObjCDeclQualifier_Inout; 8613 if (QT & Decl::OBJC_TQ_Out) 8614 Result |= CXObjCDeclQualifier_Out; 8615 if (QT & Decl::OBJC_TQ_Bycopy) 8616 Result |= CXObjCDeclQualifier_Bycopy; 8617 if (QT & Decl::OBJC_TQ_Byref) 8618 Result |= CXObjCDeclQualifier_Byref; 8619 if (QT & Decl::OBJC_TQ_Oneway) 8620 Result |= CXObjCDeclQualifier_Oneway; 8621 8622 return Result; 8623} 8624 8625unsigned clang_Cursor_isObjCOptional(CXCursor C) { 8626 if (!clang_isDeclaration(C.kind)) 8627 return 0; 8628 8629 const Decl *D = getCursorDecl(C); 8630 if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) 8631 return PD->getPropertyImplementation() == ObjCPropertyDecl::Optional; 8632 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 8633 return MD->getImplementationControl() == ObjCMethodDecl::Optional; 8634 8635 return 0; 8636} 8637 8638unsigned clang_Cursor_isVariadic(CXCursor C) { 8639 if (!clang_isDeclaration(C.kind)) 8640 return 0; 8641 8642 const Decl *D = getCursorDecl(C); 8643 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 8644 return FD->isVariadic(); 8645 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 8646 return MD->isVariadic(); 8647 8648 return 0; 8649} 8650 8651unsigned clang_Cursor_isExternalSymbol(CXCursor C, CXString *language, 8652 CXString *definedIn, 8653 unsigned *isGenerated) { 8654 if (!clang_isDeclaration(C.kind)) 8655 return 0; 8656 8657 const Decl *D = getCursorDecl(C); 8658 8659 if (auto *attr = D->getExternalSourceSymbolAttr()) { 8660 if (language) 8661 *language = cxstring::createDup(attr->getLanguage()); 8662 if (definedIn) 8663 *definedIn = cxstring::createDup(attr->getDefinedIn()); 8664 if (isGenerated) 8665 *isGenerated = attr->getGeneratedDeclaration(); 8666 return 1; 8667 } 8668 return 0; 8669} 8670 8671CXSourceRange clang_Cursor_getCommentRange(CXCursor C) { 8672 if (!clang_isDeclaration(C.kind)) 8673 return clang_getNullRange(); 8674 8675 const Decl *D = getCursorDecl(C); 8676 ASTContext &Context = getCursorContext(C); 8677 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 8678 if (!RC) 8679 return clang_getNullRange(); 8680 8681 return cxloc::translateSourceRange(Context, RC->getSourceRange()); 8682} 8683 8684CXString clang_Cursor_getRawCommentText(CXCursor C) { 8685 if (!clang_isDeclaration(C.kind)) 8686 return cxstring::createNull(); 8687 8688 const Decl *D = getCursorDecl(C); 8689 ASTContext &Context = getCursorContext(C); 8690 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 8691 StringRef RawText = 8692 RC ? RC->getRawText(Context.getSourceManager()) : StringRef(); 8693 8694 // Don't duplicate the string because RawText points directly into source 8695 // code. 8696 return cxstring::createRef(RawText); 8697} 8698 8699CXString clang_Cursor_getBriefCommentText(CXCursor C) { 8700 if (!clang_isDeclaration(C.kind)) 8701 return cxstring::createNull(); 8702 8703 const Decl *D = getCursorDecl(C); 8704 const ASTContext &Context = getCursorContext(C); 8705 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 8706 8707 if (RC) { 8708 StringRef BriefText = RC->getBriefText(Context); 8709 8710 // Don't duplicate the string because RawComment ensures that this memory 8711 // will not go away. 8712 return cxstring::createRef(BriefText); 8713 } 8714 8715 return cxstring::createNull(); 8716} 8717 8718CXModule clang_Cursor_getModule(CXCursor C) { 8719 if (C.kind == CXCursor_ModuleImportDecl) { 8720 if (const ImportDecl *ImportD = 8721 dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) 8722 return ImportD->getImportedModule(); 8723 } 8724 8725 return nullptr; 8726} 8727 8728CXModule clang_getModuleForFile(CXTranslationUnit TU, CXFile File) { 8729 if (isNotUsableTU(TU)) { 8730 LOG_BAD_TU(TU); 8731 return nullptr; 8732 } 8733 if (!File) 8734 return nullptr; 8735 FileEntry *FE = static_cast<FileEntry *>(File); 8736 8737 ASTUnit &Unit = *cxtu::getASTUnit(TU); 8738 HeaderSearch &HS = Unit.getPreprocessor().getHeaderSearchInfo(); 8739 ModuleMap::KnownHeader Header = HS.findModuleForHeader(FE); 8740 8741 return Header.getModule(); 8742} 8743 8744CXFile clang_Module_getASTFile(CXModule CXMod) { 8745 if (!CXMod) 8746 return nullptr; 8747 Module *Mod = static_cast<Module *>(CXMod); 8748 if (auto File = Mod->getASTFile()) 8749 return const_cast<FileEntry *>(&File->getFileEntry()); 8750 return nullptr; 8751} 8752 8753CXModule clang_Module_getParent(CXModule CXMod) { 8754 if (!CXMod) 8755 return nullptr; 8756 Module *Mod = static_cast<Module *>(CXMod); 8757 return Mod->Parent; 8758} 8759 8760CXString clang_Module_getName(CXModule CXMod) { 8761 if (!CXMod) 8762 return cxstring::createEmpty(); 8763 Module *Mod = static_cast<Module *>(CXMod); 8764 return cxstring::createDup(Mod->Name); 8765} 8766 8767CXString clang_Module_getFullName(CXModule CXMod) { 8768 if (!CXMod) 8769 return cxstring::createEmpty(); 8770 Module *Mod = static_cast<Module *>(CXMod); 8771 return cxstring::createDup(Mod->getFullModuleName()); 8772} 8773 8774int clang_Module_isSystem(CXModule CXMod) { 8775 if (!CXMod) 8776 return 0; 8777 Module *Mod = static_cast<Module *>(CXMod); 8778 return Mod->IsSystem; 8779} 8780 8781unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit TU, 8782 CXModule CXMod) { 8783 if (isNotUsableTU(TU)) { 8784 LOG_BAD_TU(TU); 8785 return 0; 8786 } 8787 if (!CXMod) 8788 return 0; 8789 Module *Mod = static_cast<Module *>(CXMod); 8790 FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager(); 8791 ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr); 8792 return TopHeaders.size(); 8793} 8794 8795CXFile clang_Module_getTopLevelHeader(CXTranslationUnit TU, CXModule CXMod, 8796 unsigned Index) { 8797 if (isNotUsableTU(TU)) { 8798 LOG_BAD_TU(TU); 8799 return nullptr; 8800 } 8801 if (!CXMod) 8802 return nullptr; 8803 Module *Mod = static_cast<Module *>(CXMod); 8804 FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager(); 8805 8806 ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr); 8807 if (Index < TopHeaders.size()) 8808 return const_cast<FileEntry *>(TopHeaders[Index]); 8809 8810 return nullptr; 8811} 8812 8813//===----------------------------------------------------------------------===// 8814// C++ AST instrospection. 8815//===----------------------------------------------------------------------===// 8816 8817unsigned clang_CXXConstructor_isDefaultConstructor(CXCursor C) { 8818 if (!clang_isDeclaration(C.kind)) 8819 return 0; 8820 8821 const Decl *D = cxcursor::getCursorDecl(C); 8822 const CXXConstructorDecl *Constructor = 8823 D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr; 8824 return (Constructor && Constructor->isDefaultConstructor()) ? 1 : 0; 8825} 8826 8827unsigned clang_CXXConstructor_isCopyConstructor(CXCursor C) { 8828 if (!clang_isDeclaration(C.kind)) 8829 return 0; 8830 8831 const Decl *D = cxcursor::getCursorDecl(C); 8832 const CXXConstructorDecl *Constructor = 8833 D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr; 8834 return (Constructor && Constructor->isCopyConstructor()) ? 1 : 0; 8835} 8836 8837unsigned clang_CXXConstructor_isMoveConstructor(CXCursor C) { 8838 if (!clang_isDeclaration(C.kind)) 8839 return 0; 8840 8841 const Decl *D = cxcursor::getCursorDecl(C); 8842 const CXXConstructorDecl *Constructor = 8843 D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr; 8844 return (Constructor && Constructor->isMoveConstructor()) ? 1 : 0; 8845} 8846 8847unsigned clang_CXXConstructor_isConvertingConstructor(CXCursor C) { 8848 if (!clang_isDeclaration(C.kind)) 8849 return 0; 8850 8851 const Decl *D = cxcursor::getCursorDecl(C); 8852 const CXXConstructorDecl *Constructor = 8853 D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr; 8854 // Passing 'false' excludes constructors marked 'explicit'. 8855 return (Constructor && Constructor->isConvertingConstructor(false)) ? 1 : 0; 8856} 8857 8858unsigned clang_CXXField_isMutable(CXCursor C) { 8859 if (!clang_isDeclaration(C.kind)) 8860 return 0; 8861 8862 if (const auto D = cxcursor::getCursorDecl(C)) 8863 if (const auto FD = dyn_cast_or_null<FieldDecl>(D)) 8864 return FD->isMutable() ? 1 : 0; 8865 return 0; 8866} 8867 8868unsigned clang_CXXMethod_isPureVirtual(CXCursor C) { 8869 if (!clang_isDeclaration(C.kind)) 8870 return 0; 8871 8872 const Decl *D = cxcursor::getCursorDecl(C); 8873 const CXXMethodDecl *Method = 8874 D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr; 8875 return (Method && Method->isVirtual() && Method->isPure()) ? 1 : 0; 8876} 8877 8878unsigned clang_CXXMethod_isConst(CXCursor C) { 8879 if (!clang_isDeclaration(C.kind)) 8880 return 0; 8881 8882 const Decl *D = cxcursor::getCursorDecl(C); 8883 const CXXMethodDecl *Method = 8884 D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr; 8885 return (Method && Method->getMethodQualifiers().hasConst()) ? 1 : 0; 8886} 8887 8888unsigned clang_CXXMethod_isDefaulted(CXCursor C) { 8889 if (!clang_isDeclaration(C.kind)) 8890 return 0; 8891 8892 const Decl *D = cxcursor::getCursorDecl(C); 8893 const CXXMethodDecl *Method = 8894 D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr; 8895 return (Method && Method->isDefaulted()) ? 1 : 0; 8896} 8897 8898unsigned clang_CXXMethod_isDeleted(CXCursor C) { 8899 if (!clang_isDeclaration(C.kind)) 8900 return 0; 8901 8902 const Decl *D = cxcursor::getCursorDecl(C); 8903 const CXXMethodDecl *Method = 8904 D ? dyn_cast_if_present<CXXMethodDecl>(D->getAsFunction()) : nullptr; 8905 return (Method && Method->isDeleted()) ? 1 : 0; 8906} 8907 8908unsigned clang_CXXMethod_isStatic(CXCursor C) { 8909 if (!clang_isDeclaration(C.kind)) 8910 return 0; 8911 8912 const Decl *D = cxcursor::getCursorDecl(C); 8913 const CXXMethodDecl *Method = 8914 D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr; 8915 return (Method && Method->isStatic()) ? 1 : 0; 8916} 8917 8918unsigned clang_CXXMethod_isVirtual(CXCursor C) { 8919 if (!clang_isDeclaration(C.kind)) 8920 return 0; 8921 8922 const Decl *D = cxcursor::getCursorDecl(C); 8923 const CXXMethodDecl *Method = 8924 D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr; 8925 return (Method && Method->isVirtual()) ? 1 : 0; 8926} 8927 8928unsigned clang_CXXMethod_isCopyAssignmentOperator(CXCursor C) { 8929 if (!clang_isDeclaration(C.kind)) 8930 return 0; 8931 8932 const Decl *D = cxcursor::getCursorDecl(C); 8933 const CXXMethodDecl *Method = 8934 D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr; 8935 8936 return (Method && Method->isCopyAssignmentOperator()) ? 1 : 0; 8937} 8938 8939unsigned clang_CXXMethod_isMoveAssignmentOperator(CXCursor C) { 8940 if (!clang_isDeclaration(C.kind)) 8941 return 0; 8942 8943 const Decl *D = cxcursor::getCursorDecl(C); 8944 const CXXMethodDecl *Method = 8945 D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr; 8946 8947 return (Method && Method->isMoveAssignmentOperator()) ? 1 : 0; 8948} 8949 8950unsigned clang_CXXRecord_isAbstract(CXCursor C) { 8951 if (!clang_isDeclaration(C.kind)) 8952 return 0; 8953 8954 const auto *D = cxcursor::getCursorDecl(C); 8955 const auto *RD = dyn_cast_or_null<CXXRecordDecl>(D); 8956 if (RD) 8957 RD = RD->getDefinition(); 8958 return (RD && RD->isAbstract()) ? 1 : 0; 8959} 8960 8961unsigned clang_EnumDecl_isScoped(CXCursor C) { 8962 if (!clang_isDeclaration(C.kind)) 8963 return 0; 8964 8965 const Decl *D = cxcursor::getCursorDecl(C); 8966 auto *Enum = dyn_cast_or_null<EnumDecl>(D); 8967 return (Enum && Enum->isScoped()) ? 1 : 0; 8968} 8969 8970//===----------------------------------------------------------------------===// 8971// Attribute introspection. 8972//===----------------------------------------------------------------------===// 8973 8974CXType clang_getIBOutletCollectionType(CXCursor C) { 8975 if (C.kind != CXCursor_IBOutletCollectionAttr) 8976 return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C)); 8977 8978 const IBOutletCollectionAttr *A = 8979 cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C)); 8980 8981 return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorTU(C)); 8982} 8983 8984//===----------------------------------------------------------------------===// 8985// Inspecting memory usage. 8986//===----------------------------------------------------------------------===// 8987 8988typedef std::vector<CXTUResourceUsageEntry> MemUsageEntries; 8989 8990static inline void createCXTUResourceUsageEntry(MemUsageEntries &entries, 8991 enum CXTUResourceUsageKind k, 8992 unsigned long amount) { 8993 CXTUResourceUsageEntry entry = {k, amount}; 8994 entries.push_back(entry); 8995} 8996 8997const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) { 8998 const char *str = ""; 8999 switch (kind) { 9000 case CXTUResourceUsage_AST: 9001 str = "ASTContext: expressions, declarations, and types"; 9002 break; 9003 case CXTUResourceUsage_Identifiers: 9004 str = "ASTContext: identifiers"; 9005 break; 9006 case CXTUResourceUsage_Selectors: 9007 str = "ASTContext: selectors"; 9008 break; 9009 case CXTUResourceUsage_GlobalCompletionResults: 9010 str = "Code completion: cached global results"; 9011 break; 9012 case CXTUResourceUsage_SourceManagerContentCache: 9013 str = "SourceManager: content cache allocator"; 9014 break; 9015 case CXTUResourceUsage_AST_SideTables: 9016 str = "ASTContext: side tables"; 9017 break; 9018 case CXTUResourceUsage_SourceManager_Membuffer_Malloc: 9019 str = "SourceManager: malloc'ed memory buffers"; 9020 break; 9021 case CXTUResourceUsage_SourceManager_Membuffer_MMap: 9022 str = "SourceManager: mmap'ed memory buffers"; 9023 break; 9024 case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc: 9025 str = "ExternalASTSource: malloc'ed memory buffers"; 9026 break; 9027 case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap: 9028 str = "ExternalASTSource: mmap'ed memory buffers"; 9029 break; 9030 case CXTUResourceUsage_Preprocessor: 9031 str = "Preprocessor: malloc'ed memory"; 9032 break; 9033 case CXTUResourceUsage_PreprocessingRecord: 9034 str = "Preprocessor: PreprocessingRecord"; 9035 break; 9036 case CXTUResourceUsage_SourceManager_DataStructures: 9037 str = "SourceManager: data structures and tables"; 9038 break; 9039 case CXTUResourceUsage_Preprocessor_HeaderSearch: 9040 str = "Preprocessor: header search tables"; 9041 break; 9042 } 9043 return str; 9044} 9045 9046CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU) { 9047 if (isNotUsableTU(TU)) { 9048 LOG_BAD_TU(TU); 9049 CXTUResourceUsage usage = {(void *)nullptr, 0, nullptr}; 9050 return usage; 9051 } 9052 9053 ASTUnit *astUnit = cxtu::getASTUnit(TU); 9054 std::unique_ptr<MemUsageEntries> entries(new MemUsageEntries()); 9055 ASTContext &astContext = astUnit->getASTContext(); 9056 9057 // How much memory is used by AST nodes and types? 9058 createCXTUResourceUsageEntry( 9059 *entries, CXTUResourceUsage_AST, 9060 (unsigned long)astContext.getASTAllocatedMemory()); 9061 9062 // How much memory is used by identifiers? 9063 createCXTUResourceUsageEntry( 9064 *entries, CXTUResourceUsage_Identifiers, 9065 (unsigned long)astContext.Idents.getAllocator().getTotalMemory()); 9066 9067 // How much memory is used for selectors? 9068 createCXTUResourceUsageEntry( 9069 *entries, CXTUResourceUsage_Selectors, 9070 (unsigned long)astContext.Selectors.getTotalMemory()); 9071 9072 // How much memory is used by ASTContext's side tables? 9073 createCXTUResourceUsageEntry( 9074 *entries, CXTUResourceUsage_AST_SideTables, 9075 (unsigned long)astContext.getSideTableAllocatedMemory()); 9076 9077 // How much memory is used for caching global code completion results? 9078 unsigned long completionBytes = 0; 9079 if (GlobalCodeCompletionAllocator *completionAllocator = 9080 astUnit->getCachedCompletionAllocator().get()) { 9081 completionBytes = completionAllocator->getTotalMemory(); 9082 } 9083 createCXTUResourceUsageEntry( 9084 *entries, CXTUResourceUsage_GlobalCompletionResults, completionBytes); 9085 9086 // How much memory is being used by SourceManager's content cache? 9087 createCXTUResourceUsageEntry( 9088 *entries, CXTUResourceUsage_SourceManagerContentCache, 9089 (unsigned long)astContext.getSourceManager().getContentCacheSize()); 9090 9091 // How much memory is being used by the MemoryBuffer's in SourceManager? 9092 const SourceManager::MemoryBufferSizes &srcBufs = 9093 astUnit->getSourceManager().getMemoryBufferSizes(); 9094 9095 createCXTUResourceUsageEntry(*entries, 9096 CXTUResourceUsage_SourceManager_Membuffer_Malloc, 9097 (unsigned long)srcBufs.malloc_bytes); 9098 createCXTUResourceUsageEntry(*entries, 9099 CXTUResourceUsage_SourceManager_Membuffer_MMap, 9100 (unsigned long)srcBufs.mmap_bytes); 9101 createCXTUResourceUsageEntry( 9102 *entries, CXTUResourceUsage_SourceManager_DataStructures, 9103 (unsigned long)astContext.getSourceManager().getDataStructureSizes()); 9104 9105 // How much memory is being used by the ExternalASTSource? 9106 if (ExternalASTSource *esrc = astContext.getExternalSource()) { 9107 const ExternalASTSource::MemoryBufferSizes &sizes = 9108 esrc->getMemoryBufferSizes(); 9109 9110 createCXTUResourceUsageEntry( 9111 *entries, CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc, 9112 (unsigned long)sizes.malloc_bytes); 9113 createCXTUResourceUsageEntry( 9114 *entries, CXTUResourceUsage_ExternalASTSource_Membuffer_MMap, 9115 (unsigned long)sizes.mmap_bytes); 9116 } 9117 9118 // How much memory is being used by the Preprocessor? 9119 Preprocessor &pp = astUnit->getPreprocessor(); 9120 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Preprocessor, 9121 pp.getTotalMemory()); 9122 9123 if (PreprocessingRecord *pRec = pp.getPreprocessingRecord()) { 9124 createCXTUResourceUsageEntry(*entries, 9125 CXTUResourceUsage_PreprocessingRecord, 9126 pRec->getTotalMemory()); 9127 } 9128 9129 createCXTUResourceUsageEntry(*entries, 9130 CXTUResourceUsage_Preprocessor_HeaderSearch, 9131 pp.getHeaderSearchInfo().getTotalMemory()); 9132 9133 CXTUResourceUsage usage = {(void *)entries.get(), (unsigned)entries->size(), 9134 !entries->empty() ? &(*entries)[0] : nullptr}; 9135 (void)entries.release(); 9136 return usage; 9137} 9138 9139void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage) { 9140 if (usage.data) 9141 delete (MemUsageEntries *)usage.data; 9142} 9143 9144CXSourceRangeList *clang_getSkippedRanges(CXTranslationUnit TU, CXFile file) { 9145 CXSourceRangeList *skipped = new CXSourceRangeList; 9146 skipped->count = 0; 9147 skipped->ranges = nullptr; 9148 9149 if (isNotUsableTU(TU)) { 9150 LOG_BAD_TU(TU); 9151 return skipped; 9152 } 9153 9154 if (!file) 9155 return skipped; 9156 9157 ASTUnit *astUnit = cxtu::getASTUnit(TU); 9158 PreprocessingRecord *ppRec = 9159 astUnit->getPreprocessor().getPreprocessingRecord(); 9160 if (!ppRec) 9161 return skipped; 9162 9163 ASTContext &Ctx = astUnit->getASTContext(); 9164 SourceManager &sm = Ctx.getSourceManager(); 9165 FileEntry *fileEntry = static_cast<FileEntry *>(file); 9166 FileID wantedFileID = sm.translateFile(fileEntry); 9167 bool isMainFile = wantedFileID == sm.getMainFileID(); 9168 9169 const std::vector<SourceRange> &SkippedRanges = ppRec->getSkippedRanges(); 9170 std::vector<SourceRange> wantedRanges; 9171 for (std::vector<SourceRange>::const_iterator i = SkippedRanges.begin(), 9172 ei = SkippedRanges.end(); 9173 i != ei; ++i) { 9174 if (sm.getFileID(i->getBegin()) == wantedFileID || 9175 sm.getFileID(i->getEnd()) == wantedFileID) 9176 wantedRanges.push_back(*i); 9177 else if (isMainFile && (astUnit->isInPreambleFileID(i->getBegin()) || 9178 astUnit->isInPreambleFileID(i->getEnd()))) 9179 wantedRanges.push_back(*i); 9180 } 9181 9182 skipped->count = wantedRanges.size(); 9183 skipped->ranges = new CXSourceRange[skipped->count]; 9184 for (unsigned i = 0, ei = skipped->count; i != ei; ++i) 9185 skipped->ranges[i] = cxloc::translateSourceRange(Ctx, wantedRanges[i]); 9186 9187 return skipped; 9188} 9189 9190CXSourceRangeList *clang_getAllSkippedRanges(CXTranslationUnit TU) { 9191 CXSourceRangeList *skipped = new CXSourceRangeList; 9192 skipped->count = 0; 9193 skipped->ranges = nullptr; 9194 9195 if (isNotUsableTU(TU)) { 9196 LOG_BAD_TU(TU); 9197 return skipped; 9198 } 9199 9200 ASTUnit *astUnit = cxtu::getASTUnit(TU); 9201 PreprocessingRecord *ppRec = 9202 astUnit->getPreprocessor().getPreprocessingRecord(); 9203 if (!ppRec) 9204 return skipped; 9205 9206 ASTContext &Ctx = astUnit->getASTContext(); 9207 9208 const std::vector<SourceRange> &SkippedRanges = ppRec->getSkippedRanges(); 9209 9210 skipped->count = SkippedRanges.size(); 9211 skipped->ranges = new CXSourceRange[skipped->count]; 9212 for (unsigned i = 0, ei = skipped->count; i != ei; ++i) 9213 skipped->ranges[i] = cxloc::translateSourceRange(Ctx, SkippedRanges[i]); 9214 9215 return skipped; 9216} 9217 9218void clang_disposeSourceRangeList(CXSourceRangeList *ranges) { 9219 if (ranges) { 9220 delete[] ranges->ranges; 9221 delete ranges; 9222 } 9223} 9224 9225void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) { 9226 CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU); 9227 for (unsigned I = 0; I != Usage.numEntries; ++I) 9228 fprintf(stderr, " %s: %lu\n", 9229 clang_getTUResourceUsageName(Usage.entries[I].kind), 9230 Usage.entries[I].amount); 9231 9232 clang_disposeCXTUResourceUsage(Usage); 9233} 9234 9235CXCursor clang_Cursor_getVarDeclInitializer(CXCursor cursor) { 9236 const Decl *const D = getCursorDecl(cursor); 9237 if (!D) 9238 return clang_getNullCursor(); 9239 const auto *const VD = dyn_cast<VarDecl>(D); 9240 if (!VD) 9241 return clang_getNullCursor(); 9242 const Expr *const Init = VD->getInit(); 9243 if (!Init) 9244 return clang_getNullCursor(); 9245 9246 return cxcursor::MakeCXCursor(Init, VD, cxcursor::getCursorTU(cursor)); 9247} 9248 9249int clang_Cursor_hasVarDeclGlobalStorage(CXCursor cursor) { 9250 const Decl *const D = getCursorDecl(cursor); 9251 if (!D) 9252 return -1; 9253 const auto *const VD = dyn_cast<VarDecl>(D); 9254 if (!VD) 9255 return -1; 9256 9257 return VD->hasGlobalStorage(); 9258} 9259 9260int clang_Cursor_hasVarDeclExternalStorage(CXCursor cursor) { 9261 const Decl *const D = getCursorDecl(cursor); 9262 if (!D) 9263 return -1; 9264 const auto *const VD = dyn_cast<VarDecl>(D); 9265 if (!VD) 9266 return -1; 9267 9268 return VD->hasExternalStorage(); 9269} 9270 9271//===----------------------------------------------------------------------===// 9272// Misc. utility functions. 9273//===----------------------------------------------------------------------===// 9274 9275/// Default to using our desired 8 MB stack size on "safety" threads. 9276static unsigned SafetyStackThreadSize = DesiredStackSize; 9277 9278namespace clang { 9279 9280bool RunSafely(llvm::CrashRecoveryContext &CRC, llvm::function_ref<void()> Fn, 9281 unsigned Size) { 9282 if (!Size) 9283 Size = GetSafetyThreadStackSize(); 9284 if (Size && !getenv("LIBCLANG_NOTHREADS")) 9285 return CRC.RunSafelyOnThread(Fn, Size); 9286 return CRC.RunSafely(Fn); 9287} 9288 9289unsigned GetSafetyThreadStackSize() { return SafetyStackThreadSize; } 9290 9291void SetSafetyThreadStackSize(unsigned Value) { SafetyStackThreadSize = Value; } 9292 9293} // namespace clang 9294 9295void clang::setThreadBackgroundPriority() { 9296 if (getenv("LIBCLANG_BGPRIO_DISABLE")) 9297 return; 9298 9299#if LLVM_ENABLE_THREADS 9300 // The function name setThreadBackgroundPriority is for historical reasons; 9301 // Low is more appropriate. 9302 llvm::set_thread_priority(llvm::ThreadPriority::Low); 9303#endif 9304} 9305 9306void cxindex::printDiagsToStderr(ASTUnit *Unit) { 9307 if (!Unit) 9308 return; 9309 9310 for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(), 9311 DEnd = Unit->stored_diag_end(); 9312 D != DEnd; ++D) { 9313 CXStoredDiagnostic Diag(*D, Unit->getLangOpts()); 9314 CXString Msg = 9315 clang_formatDiagnostic(&Diag, clang_defaultDiagnosticDisplayOptions()); 9316 fprintf(stderr, "%s\n", clang_getCString(Msg)); 9317 clang_disposeString(Msg); 9318 } 9319#ifdef _WIN32 9320 // On Windows, force a flush, since there may be multiple copies of 9321 // stderr and stdout in the file system, all with different buffers 9322 // but writing to the same device. 9323 fflush(stderr); 9324#endif 9325} 9326 9327MacroInfo *cxindex::getMacroInfo(const IdentifierInfo &II, 9328 SourceLocation MacroDefLoc, 9329 CXTranslationUnit TU) { 9330 if (MacroDefLoc.isInvalid() || !TU) 9331 return nullptr; 9332 if (!II.hadMacroDefinition()) 9333 return nullptr; 9334 9335 ASTUnit *Unit = cxtu::getASTUnit(TU); 9336 Preprocessor &PP = Unit->getPreprocessor(); 9337 MacroDirective *MD = PP.getLocalMacroDirectiveHistory(&II); 9338 if (MD) { 9339 for (MacroDirective::DefInfo Def = MD->getDefinition(); Def; 9340 Def = Def.getPreviousDefinition()) { 9341 if (MacroDefLoc == Def.getMacroInfo()->getDefinitionLoc()) 9342 return Def.getMacroInfo(); 9343 } 9344 } 9345 9346 return nullptr; 9347} 9348 9349const MacroInfo *cxindex::getMacroInfo(const MacroDefinitionRecord *MacroDef, 9350 CXTranslationUnit TU) { 9351 if (!MacroDef || !TU) 9352 return nullptr; 9353 const IdentifierInfo *II = MacroDef->getName(); 9354 if (!II) 9355 return nullptr; 9356 9357 return getMacroInfo(*II, MacroDef->getLocation(), TU); 9358} 9359 9360MacroDefinitionRecord * 9361cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, const Token &Tok, 9362 CXTranslationUnit TU) { 9363 if (!MI || !TU) 9364 return nullptr; 9365 if (Tok.isNot(tok::raw_identifier)) 9366 return nullptr; 9367 9368 if (MI->getNumTokens() == 0) 9369 return nullptr; 9370 SourceRange DefRange(MI->getReplacementToken(0).getLocation(), 9371 MI->getDefinitionEndLoc()); 9372 ASTUnit *Unit = cxtu::getASTUnit(TU); 9373 9374 // Check that the token is inside the definition and not its argument list. 9375 SourceManager &SM = Unit->getSourceManager(); 9376 if (SM.isBeforeInTranslationUnit(Tok.getLocation(), DefRange.getBegin())) 9377 return nullptr; 9378 if (SM.isBeforeInTranslationUnit(DefRange.getEnd(), Tok.getLocation())) 9379 return nullptr; 9380 9381 Preprocessor &PP = Unit->getPreprocessor(); 9382 PreprocessingRecord *PPRec = PP.getPreprocessingRecord(); 9383 if (!PPRec) 9384 return nullptr; 9385 9386 IdentifierInfo &II = PP.getIdentifierTable().get(Tok.getRawIdentifier()); 9387 if (!II.hadMacroDefinition()) 9388 return nullptr; 9389 9390 // Check that the identifier is not one of the macro arguments. 9391 if (llvm::is_contained(MI->params(), &II)) 9392 return nullptr; 9393 9394 MacroDirective *InnerMD = PP.getLocalMacroDirectiveHistory(&II); 9395 if (!InnerMD) 9396 return nullptr; 9397 9398 return PPRec->findMacroDefinition(InnerMD->getMacroInfo()); 9399} 9400 9401MacroDefinitionRecord * 9402cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, SourceLocation Loc, 9403 CXTranslationUnit TU) { 9404 if (Loc.isInvalid() || !MI || !TU) 9405 return nullptr; 9406 9407 if (MI->getNumTokens() == 0) 9408 return nullptr; 9409 ASTUnit *Unit = cxtu::getASTUnit(TU); 9410 Preprocessor &PP = Unit->getPreprocessor(); 9411 if (!PP.getPreprocessingRecord()) 9412 return nullptr; 9413 Loc = Unit->getSourceManager().getSpellingLoc(Loc); 9414 Token Tok; 9415 if (PP.getRawToken(Loc, Tok)) 9416 return nullptr; 9417 9418 return checkForMacroInMacroDefinition(MI, Tok, TU); 9419} 9420 9421CXString clang_getClangVersion() { 9422 return cxstring::createDup(getClangFullVersion()); 9423} 9424 9425Logger &cxindex::Logger::operator<<(CXTranslationUnit TU) { 9426 if (TU) { 9427 if (ASTUnit *Unit = cxtu::getASTUnit(TU)) { 9428 LogOS << '<' << Unit->getMainFileName() << '>'; 9429 if (Unit->isMainFileAST()) 9430 LogOS << " (" << Unit->getASTFileName() << ')'; 9431 return *this; 9432 } 9433 } else { 9434 LogOS << "<NULL TU>"; 9435 } 9436 return *this; 9437} 9438 9439Logger &cxindex::Logger::operator<<(const FileEntry *FE) { 9440 *this << FE->getName(); 9441 return *this; 9442} 9443 9444Logger &cxindex::Logger::operator<<(CXCursor cursor) { 9445 CXString cursorName = clang_getCursorDisplayName(cursor); 9446 *this << cursorName << "@" << clang_getCursorLocation(cursor); 9447 clang_disposeString(cursorName); 9448 return *this; 9449} 9450 9451Logger &cxindex::Logger::operator<<(CXSourceLocation Loc) { 9452 CXFile File; 9453 unsigned Line, Column; 9454 clang_getFileLocation(Loc, &File, &Line, &Column, nullptr); 9455 CXString FileName = clang_getFileName(File); 9456 *this << llvm::format("(%s:%d:%d)", clang_getCString(FileName), Line, Column); 9457 clang_disposeString(FileName); 9458 return *this; 9459} 9460 9461Logger &cxindex::Logger::operator<<(CXSourceRange range) { 9462 CXSourceLocation BLoc = clang_getRangeStart(range); 9463 CXSourceLocation ELoc = clang_getRangeEnd(range); 9464 9465 CXFile BFile; 9466 unsigned BLine, BColumn; 9467 clang_getFileLocation(BLoc, &BFile, &BLine, &BColumn, nullptr); 9468 9469 CXFile EFile; 9470 unsigned ELine, EColumn; 9471 clang_getFileLocation(ELoc, &EFile, &ELine, &EColumn, nullptr); 9472 9473 CXString BFileName = clang_getFileName(BFile); 9474 if (BFile == EFile) { 9475 *this << llvm::format("[%s %d:%d-%d:%d]", clang_getCString(BFileName), 9476 BLine, BColumn, ELine, EColumn); 9477 } else { 9478 CXString EFileName = clang_getFileName(EFile); 9479 *this << llvm::format("[%s:%d:%d - ", clang_getCString(BFileName), BLine, 9480 BColumn) 9481 << llvm::format("%s:%d:%d]", clang_getCString(EFileName), ELine, 9482 EColumn); 9483 clang_disposeString(EFileName); 9484 } 9485 clang_disposeString(BFileName); 9486 return *this; 9487} 9488 9489Logger &cxindex::Logger::operator<<(CXString Str) { 9490 *this << clang_getCString(Str); 9491 return *this; 9492} 9493 9494Logger &cxindex::Logger::operator<<(const llvm::format_object_base &Fmt) { 9495 LogOS << Fmt; 9496 return *this; 9497} 9498 9499static llvm::ManagedStatic<std::mutex> LoggingMutex; 9500 9501cxindex::Logger::~Logger() { 9502 std::lock_guard<std::mutex> L(*LoggingMutex); 9503 9504 static llvm::TimeRecord sBeginTR = llvm::TimeRecord::getCurrentTime(); 9505 9506 raw_ostream &OS = llvm::errs(); 9507 OS << "[libclang:" << Name << ':'; 9508 9509#ifdef USE_DARWIN_THREADS 9510 // TODO: Portability. 9511 mach_port_t tid = pthread_mach_thread_np(pthread_self()); 9512 OS << tid << ':'; 9513#endif 9514 9515 llvm::TimeRecord TR = llvm::TimeRecord::getCurrentTime(); 9516 OS << llvm::format("%7.4f] ", TR.getWallTime() - sBeginTR.getWallTime()); 9517 OS << Msg << '\n'; 9518 9519 if (Trace) { 9520 llvm::sys::PrintStackTrace(OS); 9521 OS << "--------------------------------------------------\n"; 9522 } 9523} 9524