CIndex.cpp revision 02c23ebf41ae2f70da0ba7337e05c51fbfe35f7f
1//===- CIndex.cpp - Clang-C Source Indexing Library -----------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the main API hooks in the Clang-C Source Indexing 11// library. 12// 13//===----------------------------------------------------------------------===// 14 15#include "CIndexer.h" 16#include "CXComment.h" 17#include "CXCursor.h" 18#include "CXTranslationUnit.h" 19#include "CXString.h" 20#include "CXType.h" 21#include "CXSourceLocation.h" 22#include "CIndexDiagnostic.h" 23#include "CursorVisitor.h" 24 25#include "clang/Basic/Version.h" 26 27#include "clang/AST/StmtVisitor.h" 28#include "clang/Basic/Diagnostic.h" 29#include "clang/Frontend/ASTUnit.h" 30#include "clang/Frontend/CompilerInstance.h" 31#include "clang/Frontend/FrontendDiagnostic.h" 32#include "clang/Lex/Lexer.h" 33#include "clang/Lex/HeaderSearch.h" 34#include "clang/Lex/PreprocessingRecord.h" 35#include "clang/Lex/Preprocessor.h" 36#include "llvm/ADT/STLExtras.h" 37#include "llvm/ADT/Optional.h" 38#include "llvm/ADT/StringSwitch.h" 39#include "llvm/Support/SaveAndRestore.h" 40#include "llvm/Support/CrashRecoveryContext.h" 41#include "llvm/Support/PrettyStackTrace.h" 42#include "llvm/Support/MemoryBuffer.h" 43#include "llvm/Support/raw_ostream.h" 44#include "llvm/Support/Timer.h" 45#include "llvm/Support/Mutex.h" 46#include "llvm/Support/Program.h" 47#include "llvm/Support/Signals.h" 48#include "llvm/Support/Threading.h" 49#include "llvm/Support/Compiler.h" 50 51using namespace clang; 52using namespace clang::cxcursor; 53using namespace clang::cxstring; 54using namespace clang::cxtu; 55using namespace clang::cxindex; 56 57CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx, ASTUnit *TU) { 58 if (!TU) 59 return 0; 60 CXTranslationUnit D = new CXTranslationUnitImpl(); 61 D->CIdx = CIdx; 62 D->TUData = TU; 63 D->StringPool = createCXStringPool(); 64 D->Diagnostics = 0; 65 D->OverridenCursorsPool = createOverridenCXCursorsPool(); 66 return D; 67} 68 69cxtu::CXTUOwner::~CXTUOwner() { 70 if (TU) 71 clang_disposeTranslationUnit(TU); 72} 73 74/// \brief Compare two source ranges to determine their relative position in 75/// the translation unit. 76static RangeComparisonResult RangeCompare(SourceManager &SM, 77 SourceRange R1, 78 SourceRange R2) { 79 assert(R1.isValid() && "First range is invalid?"); 80 assert(R2.isValid() && "Second range is invalid?"); 81 if (R1.getEnd() != R2.getBegin() && 82 SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin())) 83 return RangeBefore; 84 if (R2.getEnd() != R1.getBegin() && 85 SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin())) 86 return RangeAfter; 87 return RangeOverlap; 88} 89 90/// \brief Determine if a source location falls within, before, or after a 91/// a given source range. 92static RangeComparisonResult LocationCompare(SourceManager &SM, 93 SourceLocation L, SourceRange R) { 94 assert(R.isValid() && "First range is invalid?"); 95 assert(L.isValid() && "Second range is invalid?"); 96 if (L == R.getBegin() || L == R.getEnd()) 97 return RangeOverlap; 98 if (SM.isBeforeInTranslationUnit(L, R.getBegin())) 99 return RangeBefore; 100 if (SM.isBeforeInTranslationUnit(R.getEnd(), L)) 101 return RangeAfter; 102 return RangeOverlap; 103} 104 105/// \brief Translate a Clang source range into a CIndex source range. 106/// 107/// Clang internally represents ranges where the end location points to the 108/// start of the token at the end. However, for external clients it is more 109/// useful to have a CXSourceRange be a proper half-open interval. This routine 110/// does the appropriate translation. 111CXSourceRange cxloc::translateSourceRange(const SourceManager &SM, 112 const LangOptions &LangOpts, 113 const CharSourceRange &R) { 114 // We want the last character in this location, so we will adjust the 115 // location accordingly. 116 SourceLocation EndLoc = R.getEnd(); 117 if (EndLoc.isValid() && EndLoc.isMacroID() && !SM.isMacroArgExpansion(EndLoc)) 118 EndLoc = SM.getExpansionRange(EndLoc).second; 119 if (R.isTokenRange() && !EndLoc.isInvalid()) { 120 unsigned Length = Lexer::MeasureTokenLength(SM.getSpellingLoc(EndLoc), 121 SM, LangOpts); 122 EndLoc = EndLoc.getLocWithOffset(Length); 123 } 124 125 CXSourceRange Result = { { (void *)&SM, (void *)&LangOpts }, 126 R.getBegin().getRawEncoding(), 127 EndLoc.getRawEncoding() }; 128 return Result; 129} 130 131//===----------------------------------------------------------------------===// 132// Cursor visitor. 133//===----------------------------------------------------------------------===// 134 135static SourceRange getRawCursorExtent(CXCursor C); 136static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr); 137 138 139RangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) { 140 return RangeCompare(AU->getSourceManager(), R, RegionOfInterest); 141} 142 143/// \brief Visit the given cursor and, if requested by the visitor, 144/// its children. 145/// 146/// \param Cursor the cursor to visit. 147/// 148/// \param CheckedRegionOfInterest if true, then the caller already checked 149/// that this cursor is within the region of interest. 150/// 151/// \returns true if the visitation should be aborted, false if it 152/// should continue. 153bool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) { 154 if (clang_isInvalid(Cursor.kind)) 155 return false; 156 157 if (clang_isDeclaration(Cursor.kind)) { 158 Decl *D = getCursorDecl(Cursor); 159 if (!D) { 160 assert(0 && "Invalid declaration cursor"); 161 return true; // abort. 162 } 163 164 // Ignore implicit declarations, unless it's an objc method because 165 // currently we should report implicit methods for properties when indexing. 166 if (D->isImplicit() && !isa<ObjCMethodDecl>(D)) 167 return false; 168 } 169 170 // If we have a range of interest, and this cursor doesn't intersect with it, 171 // we're done. 172 if (RegionOfInterest.isValid() && !CheckedRegionOfInterest) { 173 SourceRange Range = getRawCursorExtent(Cursor); 174 if (Range.isInvalid() || CompareRegionOfInterest(Range)) 175 return false; 176 } 177 178 switch (Visitor(Cursor, Parent, ClientData)) { 179 case CXChildVisit_Break: 180 return true; 181 182 case CXChildVisit_Continue: 183 return false; 184 185 case CXChildVisit_Recurse: { 186 bool ret = VisitChildren(Cursor); 187 if (PostChildrenVisitor) 188 if (PostChildrenVisitor(Cursor, ClientData)) 189 return true; 190 return ret; 191 } 192 } 193 194 llvm_unreachable("Invalid CXChildVisitResult!"); 195} 196 197static bool visitPreprocessedEntitiesInRange(SourceRange R, 198 PreprocessingRecord &PPRec, 199 CursorVisitor &Visitor) { 200 SourceManager &SM = Visitor.getASTUnit()->getSourceManager(); 201 FileID FID; 202 203 if (!Visitor.shouldVisitIncludedEntities()) { 204 // If the begin/end of the range lie in the same FileID, do the optimization 205 // where we skip preprocessed entities that do not come from the same FileID. 206 FID = SM.getFileID(SM.getFileLoc(R.getBegin())); 207 if (FID != SM.getFileID(SM.getFileLoc(R.getEnd()))) 208 FID = FileID(); 209 } 210 211 std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator> 212 Entities = PPRec.getPreprocessedEntitiesInRange(R); 213 return Visitor.visitPreprocessedEntities(Entities.first, Entities.second, 214 PPRec, FID); 215} 216 217void CursorVisitor::visitFileRegion() { 218 if (RegionOfInterest.isInvalid()) 219 return; 220 221 ASTUnit *Unit = static_cast<ASTUnit *>(TU->TUData); 222 SourceManager &SM = Unit->getSourceManager(); 223 224 std::pair<FileID, unsigned> 225 Begin = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getBegin())), 226 End = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getEnd())); 227 228 if (End.first != Begin.first) { 229 // If the end does not reside in the same file, try to recover by 230 // picking the end of the file of begin location. 231 End.first = Begin.first; 232 End.second = SM.getFileIDSize(Begin.first); 233 } 234 235 assert(Begin.first == End.first); 236 if (Begin.second > End.second) 237 return; 238 239 FileID File = Begin.first; 240 unsigned Offset = Begin.second; 241 unsigned Length = End.second - Begin.second; 242 243 if (!VisitDeclsOnly && !VisitPreprocessorLast) 244 if (visitPreprocessedEntitiesInRegion()) 245 return; // visitation break. 246 247 visitDeclsFromFileRegion(File, Offset, Length); 248 249 if (!VisitDeclsOnly && VisitPreprocessorLast) 250 visitPreprocessedEntitiesInRegion(); 251} 252 253static bool isInLexicalContext(Decl *D, DeclContext *DC) { 254 if (!DC) 255 return false; 256 257 for (DeclContext *DeclDC = D->getLexicalDeclContext(); 258 DeclDC; DeclDC = DeclDC->getLexicalParent()) { 259 if (DeclDC == DC) 260 return true; 261 } 262 return false; 263} 264 265void CursorVisitor::visitDeclsFromFileRegion(FileID File, 266 unsigned Offset, unsigned Length) { 267 ASTUnit *Unit = static_cast<ASTUnit *>(TU->TUData); 268 SourceManager &SM = Unit->getSourceManager(); 269 SourceRange Range = RegionOfInterest; 270 271 SmallVector<Decl *, 16> Decls; 272 Unit->findFileRegionDecls(File, Offset, Length, Decls); 273 274 // If we didn't find any file level decls for the file, try looking at the 275 // file that it was included from. 276 while (Decls.empty() || Decls.front()->isTopLevelDeclInObjCContainer()) { 277 bool Invalid = false; 278 const SrcMgr::SLocEntry &SLEntry = SM.getSLocEntry(File, &Invalid); 279 if (Invalid) 280 return; 281 282 SourceLocation Outer; 283 if (SLEntry.isFile()) 284 Outer = SLEntry.getFile().getIncludeLoc(); 285 else 286 Outer = SLEntry.getExpansion().getExpansionLocStart(); 287 if (Outer.isInvalid()) 288 return; 289 290 llvm::tie(File, Offset) = SM.getDecomposedExpansionLoc(Outer); 291 Length = 0; 292 Unit->findFileRegionDecls(File, Offset, Length, Decls); 293 } 294 295 assert(!Decls.empty()); 296 297 bool VisitedAtLeastOnce = false; 298 DeclContext *CurDC = 0; 299 SmallVector<Decl *, 16>::iterator DIt = Decls.begin(); 300 for (SmallVector<Decl *, 16>::iterator DE = Decls.end(); DIt != DE; ++DIt) { 301 Decl *D = *DIt; 302 if (D->getSourceRange().isInvalid()) 303 continue; 304 305 if (isInLexicalContext(D, CurDC)) 306 continue; 307 308 CurDC = dyn_cast<DeclContext>(D); 309 310 if (TagDecl *TD = dyn_cast<TagDecl>(D)) 311 if (!TD->isFreeStanding()) 312 continue; 313 314 RangeComparisonResult CompRes = RangeCompare(SM, D->getSourceRange(),Range); 315 if (CompRes == RangeBefore) 316 continue; 317 if (CompRes == RangeAfter) 318 break; 319 320 assert(CompRes == RangeOverlap); 321 VisitedAtLeastOnce = true; 322 323 if (isa<ObjCContainerDecl>(D)) { 324 FileDI_current = &DIt; 325 FileDE_current = DE; 326 } else { 327 FileDI_current = 0; 328 } 329 330 if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true)) 331 break; 332 } 333 334 if (VisitedAtLeastOnce) 335 return; 336 337 // No Decls overlapped with the range. Move up the lexical context until there 338 // is a context that contains the range or we reach the translation unit 339 // level. 340 DeclContext *DC = DIt == Decls.begin() ? (*DIt)->getLexicalDeclContext() 341 : (*(DIt-1))->getLexicalDeclContext(); 342 343 while (DC && !DC->isTranslationUnit()) { 344 Decl *D = cast<Decl>(DC); 345 SourceRange CurDeclRange = D->getSourceRange(); 346 if (CurDeclRange.isInvalid()) 347 break; 348 349 if (RangeCompare(SM, CurDeclRange, Range) == RangeOverlap) { 350 Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true); 351 break; 352 } 353 354 DC = D->getLexicalDeclContext(); 355 } 356} 357 358bool CursorVisitor::visitPreprocessedEntitiesInRegion() { 359 if (!AU->getPreprocessor().getPreprocessingRecord()) 360 return false; 361 362 PreprocessingRecord &PPRec 363 = *AU->getPreprocessor().getPreprocessingRecord(); 364 SourceManager &SM = AU->getSourceManager(); 365 366 if (RegionOfInterest.isValid()) { 367 SourceRange MappedRange = AU->mapRangeToPreamble(RegionOfInterest); 368 SourceLocation B = MappedRange.getBegin(); 369 SourceLocation E = MappedRange.getEnd(); 370 371 if (AU->isInPreambleFileID(B)) { 372 if (SM.isLoadedSourceLocation(E)) 373 return visitPreprocessedEntitiesInRange(SourceRange(B, E), 374 PPRec, *this); 375 376 // Beginning of range lies in the preamble but it also extends beyond 377 // it into the main file. Split the range into 2 parts, one covering 378 // the preamble and another covering the main file. This allows subsequent 379 // calls to visitPreprocessedEntitiesInRange to accept a source range that 380 // lies in the same FileID, allowing it to skip preprocessed entities that 381 // do not come from the same FileID. 382 bool breaked = 383 visitPreprocessedEntitiesInRange( 384 SourceRange(B, AU->getEndOfPreambleFileID()), 385 PPRec, *this); 386 if (breaked) return true; 387 return visitPreprocessedEntitiesInRange( 388 SourceRange(AU->getStartOfMainFileID(), E), 389 PPRec, *this); 390 } 391 392 return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec, *this); 393 } 394 395 bool OnlyLocalDecls 396 = !AU->isMainFileAST() && AU->getOnlyLocalDecls(); 397 398 if (OnlyLocalDecls) 399 return visitPreprocessedEntities(PPRec.local_begin(), PPRec.local_end(), 400 PPRec); 401 402 return visitPreprocessedEntities(PPRec.begin(), PPRec.end(), PPRec); 403} 404 405template<typename InputIterator> 406bool CursorVisitor::visitPreprocessedEntities(InputIterator First, 407 InputIterator Last, 408 PreprocessingRecord &PPRec, 409 FileID FID) { 410 for (; First != Last; ++First) { 411 if (!FID.isInvalid() && !PPRec.isEntityInFileID(First, FID)) 412 continue; 413 414 PreprocessedEntity *PPE = *First; 415 if (MacroExpansion *ME = dyn_cast<MacroExpansion>(PPE)) { 416 if (Visit(MakeMacroExpansionCursor(ME, TU))) 417 return true; 418 419 continue; 420 } 421 422 if (MacroDefinition *MD = dyn_cast<MacroDefinition>(PPE)) { 423 if (Visit(MakeMacroDefinitionCursor(MD, TU))) 424 return true; 425 426 continue; 427 } 428 429 if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) { 430 if (Visit(MakeInclusionDirectiveCursor(ID, TU))) 431 return true; 432 433 continue; 434 } 435 } 436 437 return false; 438} 439 440/// \brief Visit the children of the given cursor. 441/// 442/// \returns true if the visitation should be aborted, false if it 443/// should continue. 444bool CursorVisitor::VisitChildren(CXCursor Cursor) { 445 if (clang_isReference(Cursor.kind) && 446 Cursor.kind != CXCursor_CXXBaseSpecifier) { 447 // By definition, references have no children. 448 return false; 449 } 450 451 // Set the Parent field to Cursor, then back to its old value once we're 452 // done. 453 SetParentRAII SetParent(Parent, StmtParent, Cursor); 454 455 if (clang_isDeclaration(Cursor.kind)) { 456 Decl *D = getCursorDecl(Cursor); 457 if (!D) 458 return false; 459 460 return VisitAttributes(D) || Visit(D); 461 } 462 463 if (clang_isStatement(Cursor.kind)) { 464 if (Stmt *S = getCursorStmt(Cursor)) 465 return Visit(S); 466 467 return false; 468 } 469 470 if (clang_isExpression(Cursor.kind)) { 471 if (Expr *E = getCursorExpr(Cursor)) 472 return Visit(E); 473 474 return false; 475 } 476 477 if (clang_isTranslationUnit(Cursor.kind)) { 478 CXTranslationUnit tu = getCursorTU(Cursor); 479 ASTUnit *CXXUnit = static_cast<ASTUnit*>(tu->TUData); 480 481 int VisitOrder[2] = { VisitPreprocessorLast, !VisitPreprocessorLast }; 482 for (unsigned I = 0; I != 2; ++I) { 483 if (VisitOrder[I]) { 484 if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() && 485 RegionOfInterest.isInvalid()) { 486 for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(), 487 TLEnd = CXXUnit->top_level_end(); 488 TL != TLEnd; ++TL) { 489 if (Visit(MakeCXCursor(*TL, tu, RegionOfInterest), true)) 490 return true; 491 } 492 } else if (VisitDeclContext( 493 CXXUnit->getASTContext().getTranslationUnitDecl())) 494 return true; 495 continue; 496 } 497 498 // Walk the preprocessing record. 499 if (CXXUnit->getPreprocessor().getPreprocessingRecord()) 500 visitPreprocessedEntitiesInRegion(); 501 } 502 503 return false; 504 } 505 506 if (Cursor.kind == CXCursor_CXXBaseSpecifier) { 507 if (CXXBaseSpecifier *Base = getCursorCXXBaseSpecifier(Cursor)) { 508 if (TypeSourceInfo *BaseTSInfo = Base->getTypeSourceInfo()) { 509 return Visit(BaseTSInfo->getTypeLoc()); 510 } 511 } 512 } 513 514 if (Cursor.kind == CXCursor_IBOutletCollectionAttr) { 515 IBOutletCollectionAttr *A = 516 cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(Cursor)); 517 if (const ObjCInterfaceType *InterT = A->getInterface()->getAs<ObjCInterfaceType>()) 518 return Visit(cxcursor::MakeCursorObjCClassRef(InterT->getInterface(), 519 A->getInterfaceLoc(), TU)); 520 } 521 522 // Nothing to visit at the moment. 523 return false; 524} 525 526bool CursorVisitor::VisitBlockDecl(BlockDecl *B) { 527 if (TypeSourceInfo *TSInfo = B->getSignatureAsWritten()) 528 if (Visit(TSInfo->getTypeLoc())) 529 return true; 530 531 if (Stmt *Body = B->getBody()) 532 return Visit(MakeCXCursor(Body, StmtParent, TU, RegionOfInterest)); 533 534 return false; 535} 536 537llvm::Optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) { 538 if (RegionOfInterest.isValid()) { 539 SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager()); 540 if (Range.isInvalid()) 541 return llvm::Optional<bool>(); 542 543 switch (CompareRegionOfInterest(Range)) { 544 case RangeBefore: 545 // This declaration comes before the region of interest; skip it. 546 return llvm::Optional<bool>(); 547 548 case RangeAfter: 549 // This declaration comes after the region of interest; we're done. 550 return false; 551 552 case RangeOverlap: 553 // This declaration overlaps the region of interest; visit it. 554 break; 555 } 556 } 557 return true; 558} 559 560bool CursorVisitor::VisitDeclContext(DeclContext *DC) { 561 DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end(); 562 563 // FIXME: Eventually remove. This part of a hack to support proper 564 // iteration over all Decls contained lexically within an ObjC container. 565 SaveAndRestore<DeclContext::decl_iterator*> DI_saved(DI_current, &I); 566 SaveAndRestore<DeclContext::decl_iterator> DE_saved(DE_current, E); 567 568 for ( ; I != E; ++I) { 569 Decl *D = *I; 570 if (D->getLexicalDeclContext() != DC) 571 continue; 572 CXCursor Cursor = MakeCXCursor(D, TU, RegionOfInterest); 573 574 // Ignore synthesized ivars here, otherwise if we have something like: 575 // @synthesize prop = _prop; 576 // and '_prop' is not declared, we will encounter a '_prop' ivar before 577 // encountering the 'prop' synthesize declaration and we will think that 578 // we passed the region-of-interest. 579 if (ObjCIvarDecl *ivarD = dyn_cast<ObjCIvarDecl>(D)) { 580 if (ivarD->getSynthesize()) 581 continue; 582 } 583 584 // FIXME: ObjCClassRef/ObjCProtocolRef for forward class/protocol 585 // declarations is a mismatch with the compiler semantics. 586 if (Cursor.kind == CXCursor_ObjCInterfaceDecl) { 587 ObjCInterfaceDecl *ID = cast<ObjCInterfaceDecl>(D); 588 if (!ID->isThisDeclarationADefinition()) 589 Cursor = MakeCursorObjCClassRef(ID, ID->getLocation(), TU); 590 591 } else if (Cursor.kind == CXCursor_ObjCProtocolDecl) { 592 ObjCProtocolDecl *PD = cast<ObjCProtocolDecl>(D); 593 if (!PD->isThisDeclarationADefinition()) 594 Cursor = MakeCursorObjCProtocolRef(PD, PD->getLocation(), TU); 595 } 596 597 const llvm::Optional<bool> &V = shouldVisitCursor(Cursor); 598 if (!V.hasValue()) 599 continue; 600 if (!V.getValue()) 601 return false; 602 if (Visit(Cursor, true)) 603 return true; 604 } 605 return false; 606} 607 608bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 609 llvm_unreachable("Translation units are visited directly by Visit()"); 610} 611 612bool CursorVisitor::VisitTypeAliasDecl(TypeAliasDecl *D) { 613 if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo()) 614 return Visit(TSInfo->getTypeLoc()); 615 616 return false; 617} 618 619bool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) { 620 if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo()) 621 return Visit(TSInfo->getTypeLoc()); 622 623 return false; 624} 625 626bool CursorVisitor::VisitTagDecl(TagDecl *D) { 627 return VisitDeclContext(D); 628} 629 630bool CursorVisitor::VisitClassTemplateSpecializationDecl( 631 ClassTemplateSpecializationDecl *D) { 632 bool ShouldVisitBody = false; 633 switch (D->getSpecializationKind()) { 634 case TSK_Undeclared: 635 case TSK_ImplicitInstantiation: 636 // Nothing to visit 637 return false; 638 639 case TSK_ExplicitInstantiationDeclaration: 640 case TSK_ExplicitInstantiationDefinition: 641 break; 642 643 case TSK_ExplicitSpecialization: 644 ShouldVisitBody = true; 645 break; 646 } 647 648 // Visit the template arguments used in the specialization. 649 if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) { 650 TypeLoc TL = SpecType->getTypeLoc(); 651 if (TemplateSpecializationTypeLoc *TSTLoc 652 = dyn_cast<TemplateSpecializationTypeLoc>(&TL)) { 653 for (unsigned I = 0, N = TSTLoc->getNumArgs(); I != N; ++I) 654 if (VisitTemplateArgumentLoc(TSTLoc->getArgLoc(I))) 655 return true; 656 } 657 } 658 659 if (ShouldVisitBody && VisitCXXRecordDecl(D)) 660 return true; 661 662 return false; 663} 664 665bool CursorVisitor::VisitClassTemplatePartialSpecializationDecl( 666 ClassTemplatePartialSpecializationDecl *D) { 667 // FIXME: Visit the "outer" template parameter lists on the TagDecl 668 // before visiting these template parameters. 669 if (VisitTemplateParameters(D->getTemplateParameters())) 670 return true; 671 672 // Visit the partial specialization arguments. 673 const TemplateArgumentLoc *TemplateArgs = D->getTemplateArgsAsWritten(); 674 for (unsigned I = 0, N = D->getNumTemplateArgsAsWritten(); I != N; ++I) 675 if (VisitTemplateArgumentLoc(TemplateArgs[I])) 676 return true; 677 678 return VisitCXXRecordDecl(D); 679} 680 681bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 682 // Visit the default argument. 683 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 684 if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo()) 685 if (Visit(DefArg->getTypeLoc())) 686 return true; 687 688 return false; 689} 690 691bool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) { 692 if (Expr *Init = D->getInitExpr()) 693 return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest)); 694 return false; 695} 696 697bool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) { 698 if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo()) 699 if (Visit(TSInfo->getTypeLoc())) 700 return true; 701 702 // Visit the nested-name-specifier, if present. 703 if (NestedNameSpecifierLoc QualifierLoc = DD->getQualifierLoc()) 704 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 705 return true; 706 707 return false; 708} 709 710/// \brief Compare two base or member initializers based on their source order. 711static int CompareCXXCtorInitializers(const void* Xp, const void *Yp) { 712 CXXCtorInitializer const * const *X 713 = static_cast<CXXCtorInitializer const * const *>(Xp); 714 CXXCtorInitializer const * const *Y 715 = static_cast<CXXCtorInitializer const * const *>(Yp); 716 717 if ((*X)->getSourceOrder() < (*Y)->getSourceOrder()) 718 return -1; 719 else if ((*X)->getSourceOrder() > (*Y)->getSourceOrder()) 720 return 1; 721 else 722 return 0; 723} 724 725bool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) { 726 if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) { 727 // Visit the function declaration's syntactic components in the order 728 // written. This requires a bit of work. 729 TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens(); 730 FunctionTypeLoc *FTL = dyn_cast<FunctionTypeLoc>(&TL); 731 732 // If we have a function declared directly (without the use of a typedef), 733 // visit just the return type. Otherwise, just visit the function's type 734 // now. 735 if ((FTL && !isa<CXXConversionDecl>(ND) && Visit(FTL->getResultLoc())) || 736 (!FTL && Visit(TL))) 737 return true; 738 739 // Visit the nested-name-specifier, if present. 740 if (NestedNameSpecifierLoc QualifierLoc = ND->getQualifierLoc()) 741 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 742 return true; 743 744 // Visit the declaration name. 745 if (VisitDeclarationNameInfo(ND->getNameInfo())) 746 return true; 747 748 // FIXME: Visit explicitly-specified template arguments! 749 750 // Visit the function parameters, if we have a function type. 751 if (FTL && VisitFunctionTypeLoc(*FTL, true)) 752 return true; 753 754 // FIXME: Attributes? 755 } 756 757 if (ND->doesThisDeclarationHaveABody() && !ND->isLateTemplateParsed()) { 758 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) { 759 // Find the initializers that were written in the source. 760 SmallVector<CXXCtorInitializer *, 4> WrittenInits; 761 for (CXXConstructorDecl::init_iterator I = Constructor->init_begin(), 762 IEnd = Constructor->init_end(); 763 I != IEnd; ++I) { 764 if (!(*I)->isWritten()) 765 continue; 766 767 WrittenInits.push_back(*I); 768 } 769 770 // Sort the initializers in source order 771 llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(), 772 &CompareCXXCtorInitializers); 773 774 // Visit the initializers in source order 775 for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) { 776 CXXCtorInitializer *Init = WrittenInits[I]; 777 if (Init->isAnyMemberInitializer()) { 778 if (Visit(MakeCursorMemberRef(Init->getAnyMember(), 779 Init->getMemberLocation(), TU))) 780 return true; 781 } else if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) { 782 if (Visit(TInfo->getTypeLoc())) 783 return true; 784 } 785 786 // Visit the initializer value. 787 if (Expr *Initializer = Init->getInit()) 788 if (Visit(MakeCXCursor(Initializer, ND, TU, RegionOfInterest))) 789 return true; 790 } 791 } 792 793 if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest))) 794 return true; 795 } 796 797 return false; 798} 799 800bool CursorVisitor::VisitFieldDecl(FieldDecl *D) { 801 if (VisitDeclaratorDecl(D)) 802 return true; 803 804 if (Expr *BitWidth = D->getBitWidth()) 805 return Visit(MakeCXCursor(BitWidth, StmtParent, TU, RegionOfInterest)); 806 807 return false; 808} 809 810bool CursorVisitor::VisitVarDecl(VarDecl *D) { 811 if (VisitDeclaratorDecl(D)) 812 return true; 813 814 if (Expr *Init = D->getInit()) 815 return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest)); 816 817 return false; 818} 819 820bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 821 if (VisitDeclaratorDecl(D)) 822 return true; 823 824 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 825 if (Expr *DefArg = D->getDefaultArgument()) 826 return Visit(MakeCXCursor(DefArg, StmtParent, TU, RegionOfInterest)); 827 828 return false; 829} 830 831bool CursorVisitor::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 832 // FIXME: Visit the "outer" template parameter lists on the FunctionDecl 833 // before visiting these template parameters. 834 if (VisitTemplateParameters(D->getTemplateParameters())) 835 return true; 836 837 return VisitFunctionDecl(D->getTemplatedDecl()); 838} 839 840bool CursorVisitor::VisitClassTemplateDecl(ClassTemplateDecl *D) { 841 // FIXME: Visit the "outer" template parameter lists on the TagDecl 842 // before visiting these template parameters. 843 if (VisitTemplateParameters(D->getTemplateParameters())) 844 return true; 845 846 return VisitCXXRecordDecl(D->getTemplatedDecl()); 847} 848 849bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 850 if (VisitTemplateParameters(D->getTemplateParameters())) 851 return true; 852 853 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() && 854 VisitTemplateArgumentLoc(D->getDefaultArgument())) 855 return true; 856 857 return false; 858} 859 860bool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) { 861 if (TypeSourceInfo *TSInfo = ND->getResultTypeSourceInfo()) 862 if (Visit(TSInfo->getTypeLoc())) 863 return true; 864 865 for (ObjCMethodDecl::param_iterator P = ND->param_begin(), 866 PEnd = ND->param_end(); 867 P != PEnd; ++P) { 868 if (Visit(MakeCXCursor(*P, TU, RegionOfInterest))) 869 return true; 870 } 871 872 if (ND->isThisDeclarationADefinition() && 873 Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest))) 874 return true; 875 876 return false; 877} 878 879template <typename DeclIt> 880static void addRangedDeclsInContainer(DeclIt *DI_current, DeclIt DE_current, 881 SourceManager &SM, SourceLocation EndLoc, 882 SmallVectorImpl<Decl *> &Decls) { 883 DeclIt next = *DI_current; 884 while (++next != DE_current) { 885 Decl *D_next = *next; 886 if (!D_next) 887 break; 888 SourceLocation L = D_next->getLocStart(); 889 if (!L.isValid()) 890 break; 891 if (SM.isBeforeInTranslationUnit(L, EndLoc)) { 892 *DI_current = next; 893 Decls.push_back(D_next); 894 continue; 895 } 896 break; 897 } 898} 899 900namespace { 901 struct ContainerDeclsSort { 902 SourceManager &SM; 903 ContainerDeclsSort(SourceManager &sm) : SM(sm) {} 904 bool operator()(Decl *A, Decl *B) { 905 SourceLocation L_A = A->getLocStart(); 906 SourceLocation L_B = B->getLocStart(); 907 assert(L_A.isValid() && L_B.isValid()); 908 return SM.isBeforeInTranslationUnit(L_A, L_B); 909 } 910 }; 911} 912 913bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) { 914 // FIXME: Eventually convert back to just 'VisitDeclContext()'. Essentially 915 // an @implementation can lexically contain Decls that are not properly 916 // nested in the AST. When we identify such cases, we need to retrofit 917 // this nesting here. 918 if (!DI_current && !FileDI_current) 919 return VisitDeclContext(D); 920 921 // Scan the Decls that immediately come after the container 922 // in the current DeclContext. If any fall within the 923 // container's lexical region, stash them into a vector 924 // for later processing. 925 SmallVector<Decl *, 24> DeclsInContainer; 926 SourceLocation EndLoc = D->getSourceRange().getEnd(); 927 SourceManager &SM = AU->getSourceManager(); 928 if (EndLoc.isValid()) { 929 if (DI_current) { 930 addRangedDeclsInContainer(DI_current, DE_current, SM, EndLoc, 931 DeclsInContainer); 932 } else { 933 addRangedDeclsInContainer(FileDI_current, FileDE_current, SM, EndLoc, 934 DeclsInContainer); 935 } 936 } 937 938 // The common case. 939 if (DeclsInContainer.empty()) 940 return VisitDeclContext(D); 941 942 // Get all the Decls in the DeclContext, and sort them with the 943 // additional ones we've collected. Then visit them. 944 for (DeclContext::decl_iterator I = D->decls_begin(), E = D->decls_end(); 945 I!=E; ++I) { 946 Decl *subDecl = *I; 947 if (!subDecl || subDecl->getLexicalDeclContext() != D || 948 subDecl->getLocStart().isInvalid()) 949 continue; 950 DeclsInContainer.push_back(subDecl); 951 } 952 953 // Now sort the Decls so that they appear in lexical order. 954 std::sort(DeclsInContainer.begin(), DeclsInContainer.end(), 955 ContainerDeclsSort(SM)); 956 957 // Now visit the decls. 958 for (SmallVectorImpl<Decl*>::iterator I = DeclsInContainer.begin(), 959 E = DeclsInContainer.end(); I != E; ++I) { 960 CXCursor Cursor = MakeCXCursor(*I, TU, RegionOfInterest); 961 const llvm::Optional<bool> &V = shouldVisitCursor(Cursor); 962 if (!V.hasValue()) 963 continue; 964 if (!V.getValue()) 965 return false; 966 if (Visit(Cursor, true)) 967 return true; 968 } 969 return false; 970} 971 972bool CursorVisitor::VisitObjCCategoryDecl(ObjCCategoryDecl *ND) { 973 if (Visit(MakeCursorObjCClassRef(ND->getClassInterface(), ND->getLocation(), 974 TU))) 975 return true; 976 977 ObjCCategoryDecl::protocol_loc_iterator PL = ND->protocol_loc_begin(); 978 for (ObjCCategoryDecl::protocol_iterator I = ND->protocol_begin(), 979 E = ND->protocol_end(); I != E; ++I, ++PL) 980 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 981 return true; 982 983 return VisitObjCContainerDecl(ND); 984} 985 986bool CursorVisitor::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) { 987 if (!PID->isThisDeclarationADefinition()) 988 return Visit(MakeCursorObjCProtocolRef(PID, PID->getLocation(), TU)); 989 990 ObjCProtocolDecl::protocol_loc_iterator PL = PID->protocol_loc_begin(); 991 for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(), 992 E = PID->protocol_end(); I != E; ++I, ++PL) 993 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 994 return true; 995 996 return VisitObjCContainerDecl(PID); 997} 998 999bool CursorVisitor::VisitObjCPropertyDecl(ObjCPropertyDecl *PD) { 1000 if (PD->getTypeSourceInfo() && Visit(PD->getTypeSourceInfo()->getTypeLoc())) 1001 return true; 1002 1003 // FIXME: This implements a workaround with @property declarations also being 1004 // installed in the DeclContext for the @interface. Eventually this code 1005 // should be removed. 1006 ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(PD->getDeclContext()); 1007 if (!CDecl || !CDecl->IsClassExtension()) 1008 return false; 1009 1010 ObjCInterfaceDecl *ID = CDecl->getClassInterface(); 1011 if (!ID) 1012 return false; 1013 1014 IdentifierInfo *PropertyId = PD->getIdentifier(); 1015 ObjCPropertyDecl *prevDecl = 1016 ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(ID), PropertyId); 1017 1018 if (!prevDecl) 1019 return false; 1020 1021 // Visit synthesized methods since they will be skipped when visiting 1022 // the @interface. 1023 if (ObjCMethodDecl *MD = prevDecl->getGetterMethodDecl()) 1024 if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl) 1025 if (Visit(MakeCXCursor(MD, TU, RegionOfInterest))) 1026 return true; 1027 1028 if (ObjCMethodDecl *MD = prevDecl->getSetterMethodDecl()) 1029 if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl) 1030 if (Visit(MakeCXCursor(MD, TU, RegionOfInterest))) 1031 return true; 1032 1033 return false; 1034} 1035 1036bool CursorVisitor::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 1037 if (!D->isThisDeclarationADefinition()) { 1038 // Forward declaration is treated like a reference. 1039 return Visit(MakeCursorObjCClassRef(D, D->getLocation(), TU)); 1040 } 1041 1042 // Issue callbacks for super class. 1043 if (D->getSuperClass() && 1044 Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(), 1045 D->getSuperClassLoc(), 1046 TU))) 1047 return true; 1048 1049 ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(); 1050 for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(), 1051 E = D->protocol_end(); I != E; ++I, ++PL) 1052 if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1053 return true; 1054 1055 return VisitObjCContainerDecl(D); 1056} 1057 1058bool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) { 1059 return VisitObjCContainerDecl(D); 1060} 1061 1062bool CursorVisitor::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 1063 // 'ID' could be null when dealing with invalid code. 1064 if (ObjCInterfaceDecl *ID = D->getClassInterface()) 1065 if (Visit(MakeCursorObjCClassRef(ID, D->getLocation(), TU))) 1066 return true; 1067 1068 return VisitObjCImplDecl(D); 1069} 1070 1071bool CursorVisitor::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 1072#if 0 1073 // Issue callbacks for super class. 1074 // FIXME: No source location information! 1075 if (D->getSuperClass() && 1076 Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(), 1077 D->getSuperClassLoc(), 1078 TU))) 1079 return true; 1080#endif 1081 1082 return VisitObjCImplDecl(D); 1083} 1084 1085bool CursorVisitor::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD) { 1086 if (ObjCIvarDecl *Ivar = PD->getPropertyIvarDecl()) 1087 if (PD->isIvarNameSpecified()) 1088 return Visit(MakeCursorMemberRef(Ivar, PD->getPropertyIvarDeclLoc(), TU)); 1089 1090 return false; 1091} 1092 1093bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) { 1094 return VisitDeclContext(D); 1095} 1096 1097bool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 1098 // Visit nested-name-specifier. 1099 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1100 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1101 return true; 1102 1103 return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(), 1104 D->getTargetNameLoc(), TU)); 1105} 1106 1107bool CursorVisitor::VisitUsingDecl(UsingDecl *D) { 1108 // Visit nested-name-specifier. 1109 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) { 1110 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1111 return true; 1112 } 1113 1114 if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU))) 1115 return true; 1116 1117 return VisitDeclarationNameInfo(D->getNameInfo()); 1118} 1119 1120bool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 1121 // Visit nested-name-specifier. 1122 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1123 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1124 return true; 1125 1126 return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(), 1127 D->getIdentLocation(), TU)); 1128} 1129 1130bool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 1131 // Visit nested-name-specifier. 1132 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) { 1133 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1134 return true; 1135 } 1136 1137 return VisitDeclarationNameInfo(D->getNameInfo()); 1138} 1139 1140bool CursorVisitor::VisitUnresolvedUsingTypenameDecl( 1141 UnresolvedUsingTypenameDecl *D) { 1142 // Visit nested-name-specifier. 1143 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1144 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1145 return true; 1146 1147 return false; 1148} 1149 1150bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) { 1151 switch (Name.getName().getNameKind()) { 1152 case clang::DeclarationName::Identifier: 1153 case clang::DeclarationName::CXXLiteralOperatorName: 1154 case clang::DeclarationName::CXXOperatorName: 1155 case clang::DeclarationName::CXXUsingDirective: 1156 return false; 1157 1158 case clang::DeclarationName::CXXConstructorName: 1159 case clang::DeclarationName::CXXDestructorName: 1160 case clang::DeclarationName::CXXConversionFunctionName: 1161 if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo()) 1162 return Visit(TSInfo->getTypeLoc()); 1163 return false; 1164 1165 case clang::DeclarationName::ObjCZeroArgSelector: 1166 case clang::DeclarationName::ObjCOneArgSelector: 1167 case clang::DeclarationName::ObjCMultiArgSelector: 1168 // FIXME: Per-identifier location info? 1169 return false; 1170 } 1171 1172 llvm_unreachable("Invalid DeclarationName::Kind!"); 1173} 1174 1175bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS, 1176 SourceRange Range) { 1177 // FIXME: This whole routine is a hack to work around the lack of proper 1178 // source information in nested-name-specifiers (PR5791). Since we do have 1179 // a beginning source location, we can visit the first component of the 1180 // nested-name-specifier, if it's a single-token component. 1181 if (!NNS) 1182 return false; 1183 1184 // Get the first component in the nested-name-specifier. 1185 while (NestedNameSpecifier *Prefix = NNS->getPrefix()) 1186 NNS = Prefix; 1187 1188 switch (NNS->getKind()) { 1189 case NestedNameSpecifier::Namespace: 1190 return Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(), 1191 TU)); 1192 1193 case NestedNameSpecifier::NamespaceAlias: 1194 return Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 1195 Range.getBegin(), TU)); 1196 1197 case NestedNameSpecifier::TypeSpec: { 1198 // If the type has a form where we know that the beginning of the source 1199 // range matches up with a reference cursor. Visit the appropriate reference 1200 // cursor. 1201 const Type *T = NNS->getAsType(); 1202 if (const TypedefType *Typedef = dyn_cast<TypedefType>(T)) 1203 return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU)); 1204 if (const TagType *Tag = dyn_cast<TagType>(T)) 1205 return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU)); 1206 if (const TemplateSpecializationType *TST 1207 = dyn_cast<TemplateSpecializationType>(T)) 1208 return VisitTemplateName(TST->getTemplateName(), Range.getBegin()); 1209 break; 1210 } 1211 1212 case NestedNameSpecifier::TypeSpecWithTemplate: 1213 case NestedNameSpecifier::Global: 1214 case NestedNameSpecifier::Identifier: 1215 break; 1216 } 1217 1218 return false; 1219} 1220 1221bool 1222CursorVisitor::VisitNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) { 1223 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; 1224 for (; Qualifier; Qualifier = Qualifier.getPrefix()) 1225 Qualifiers.push_back(Qualifier); 1226 1227 while (!Qualifiers.empty()) { 1228 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val(); 1229 NestedNameSpecifier *NNS = Q.getNestedNameSpecifier(); 1230 switch (NNS->getKind()) { 1231 case NestedNameSpecifier::Namespace: 1232 if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), 1233 Q.getLocalBeginLoc(), 1234 TU))) 1235 return true; 1236 1237 break; 1238 1239 case NestedNameSpecifier::NamespaceAlias: 1240 if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 1241 Q.getLocalBeginLoc(), 1242 TU))) 1243 return true; 1244 1245 break; 1246 1247 case NestedNameSpecifier::TypeSpec: 1248 case NestedNameSpecifier::TypeSpecWithTemplate: 1249 if (Visit(Q.getTypeLoc())) 1250 return true; 1251 1252 break; 1253 1254 case NestedNameSpecifier::Global: 1255 case NestedNameSpecifier::Identifier: 1256 break; 1257 } 1258 } 1259 1260 return false; 1261} 1262 1263bool CursorVisitor::VisitTemplateParameters( 1264 const TemplateParameterList *Params) { 1265 if (!Params) 1266 return false; 1267 1268 for (TemplateParameterList::const_iterator P = Params->begin(), 1269 PEnd = Params->end(); 1270 P != PEnd; ++P) { 1271 if (Visit(MakeCXCursor(*P, TU, RegionOfInterest))) 1272 return true; 1273 } 1274 1275 return false; 1276} 1277 1278bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) { 1279 switch (Name.getKind()) { 1280 case TemplateName::Template: 1281 return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU)); 1282 1283 case TemplateName::OverloadedTemplate: 1284 // Visit the overloaded template set. 1285 if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU))) 1286 return true; 1287 1288 return false; 1289 1290 case TemplateName::DependentTemplate: 1291 // FIXME: Visit nested-name-specifier. 1292 return false; 1293 1294 case TemplateName::QualifiedTemplate: 1295 // FIXME: Visit nested-name-specifier. 1296 return Visit(MakeCursorTemplateRef( 1297 Name.getAsQualifiedTemplateName()->getDecl(), 1298 Loc, TU)); 1299 1300 case TemplateName::SubstTemplateTemplateParm: 1301 return Visit(MakeCursorTemplateRef( 1302 Name.getAsSubstTemplateTemplateParm()->getParameter(), 1303 Loc, TU)); 1304 1305 case TemplateName::SubstTemplateTemplateParmPack: 1306 return Visit(MakeCursorTemplateRef( 1307 Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(), 1308 Loc, TU)); 1309 } 1310 1311 llvm_unreachable("Invalid TemplateName::Kind!"); 1312} 1313 1314bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) { 1315 switch (TAL.getArgument().getKind()) { 1316 case TemplateArgument::Null: 1317 case TemplateArgument::Integral: 1318 case TemplateArgument::Pack: 1319 return false; 1320 1321 case TemplateArgument::Type: 1322 if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo()) 1323 return Visit(TSInfo->getTypeLoc()); 1324 return false; 1325 1326 case TemplateArgument::Declaration: 1327 if (Expr *E = TAL.getSourceDeclExpression()) 1328 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1329 return false; 1330 1331 case TemplateArgument::NullPtr: 1332 if (Expr *E = TAL.getSourceNullPtrExpression()) 1333 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1334 return false; 1335 1336 case TemplateArgument::Expression: 1337 if (Expr *E = TAL.getSourceExpression()) 1338 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1339 return false; 1340 1341 case TemplateArgument::Template: 1342 case TemplateArgument::TemplateExpansion: 1343 if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc())) 1344 return true; 1345 1346 return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(), 1347 TAL.getTemplateNameLoc()); 1348 } 1349 1350 llvm_unreachable("Invalid TemplateArgument::Kind!"); 1351} 1352 1353bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 1354 return VisitDeclContext(D); 1355} 1356 1357bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 1358 return Visit(TL.getUnqualifiedLoc()); 1359} 1360 1361bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 1362 ASTContext &Context = AU->getASTContext(); 1363 1364 // Some builtin types (such as Objective-C's "id", "sel", and 1365 // "Class") have associated declarations. Create cursors for those. 1366 QualType VisitType; 1367 switch (TL.getTypePtr()->getKind()) { 1368 1369 case BuiltinType::Void: 1370 case BuiltinType::NullPtr: 1371 case BuiltinType::Dependent: 1372#define BUILTIN_TYPE(Id, SingletonId) 1373#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: 1374#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: 1375#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id: 1376#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id: 1377#include "clang/AST/BuiltinTypes.def" 1378 break; 1379 1380 case BuiltinType::ObjCId: 1381 VisitType = Context.getObjCIdType(); 1382 break; 1383 1384 case BuiltinType::ObjCClass: 1385 VisitType = Context.getObjCClassType(); 1386 break; 1387 1388 case BuiltinType::ObjCSel: 1389 VisitType = Context.getObjCSelType(); 1390 break; 1391 } 1392 1393 if (!VisitType.isNull()) { 1394 if (const TypedefType *Typedef = VisitType->getAs<TypedefType>()) 1395 return Visit(MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(), 1396 TU)); 1397 } 1398 1399 return false; 1400} 1401 1402bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 1403 return Visit(MakeCursorTypeRef(TL.getTypedefNameDecl(), TL.getNameLoc(), TU)); 1404} 1405 1406bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 1407 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1408} 1409 1410bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) { 1411 if (TL.isDefinition()) 1412 return Visit(MakeCXCursor(TL.getDecl(), TU, RegionOfInterest)); 1413 1414 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1415} 1416 1417bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 1418 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1419} 1420 1421bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 1422 if (Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU))) 1423 return true; 1424 1425 return false; 1426} 1427 1428bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 1429 if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc())) 1430 return true; 1431 1432 for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) { 1433 if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I), 1434 TU))) 1435 return true; 1436 } 1437 1438 return false; 1439} 1440 1441bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 1442 return Visit(TL.getPointeeLoc()); 1443} 1444 1445bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) { 1446 return Visit(TL.getInnerLoc()); 1447} 1448 1449bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) { 1450 return Visit(TL.getPointeeLoc()); 1451} 1452 1453bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 1454 return Visit(TL.getPointeeLoc()); 1455} 1456 1457bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 1458 return Visit(TL.getPointeeLoc()); 1459} 1460 1461bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 1462 return Visit(TL.getPointeeLoc()); 1463} 1464 1465bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 1466 return Visit(TL.getPointeeLoc()); 1467} 1468 1469bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 1470 return Visit(TL.getModifiedLoc()); 1471} 1472 1473bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL, 1474 bool SkipResultType) { 1475 if (!SkipResultType && Visit(TL.getResultLoc())) 1476 return true; 1477 1478 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1479 if (Decl *D = TL.getArg(I)) 1480 if (Visit(MakeCXCursor(D, TU, RegionOfInterest))) 1481 return true; 1482 1483 return false; 1484} 1485 1486bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) { 1487 if (Visit(TL.getElementLoc())) 1488 return true; 1489 1490 if (Expr *Size = TL.getSizeExpr()) 1491 return Visit(MakeCXCursor(Size, StmtParent, TU, RegionOfInterest)); 1492 1493 return false; 1494} 1495 1496bool CursorVisitor::VisitTemplateSpecializationTypeLoc( 1497 TemplateSpecializationTypeLoc TL) { 1498 // Visit the template name. 1499 if (VisitTemplateName(TL.getTypePtr()->getTemplateName(), 1500 TL.getTemplateNameLoc())) 1501 return true; 1502 1503 // Visit the template arguments. 1504 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1505 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1506 return true; 1507 1508 return false; 1509} 1510 1511bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 1512 return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU)); 1513} 1514 1515bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 1516 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo()) 1517 return Visit(TSInfo->getTypeLoc()); 1518 1519 return false; 1520} 1521 1522bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 1523 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo()) 1524 return Visit(TSInfo->getTypeLoc()); 1525 1526 return false; 1527} 1528 1529bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 1530 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1531 return true; 1532 1533 return false; 1534} 1535 1536bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc( 1537 DependentTemplateSpecializationTypeLoc TL) { 1538 // Visit the nested-name-specifier, if there is one. 1539 if (TL.getQualifierLoc() && 1540 VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1541 return true; 1542 1543 // Visit the template arguments. 1544 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1545 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1546 return true; 1547 1548 return false; 1549} 1550 1551bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 1552 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1553 return true; 1554 1555 return Visit(TL.getNamedTypeLoc()); 1556} 1557 1558bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 1559 return Visit(TL.getPatternLoc()); 1560} 1561 1562bool CursorVisitor::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 1563 if (Expr *E = TL.getUnderlyingExpr()) 1564 return Visit(MakeCXCursor(E, StmtParent, TU)); 1565 1566 return false; 1567} 1568 1569bool CursorVisitor::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 1570 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1571} 1572 1573bool CursorVisitor::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 1574 return Visit(TL.getValueLoc()); 1575} 1576 1577#define DEFAULT_TYPELOC_IMPL(CLASS, PARENT) \ 1578bool CursorVisitor::Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { \ 1579 return Visit##PARENT##Loc(TL); \ 1580} 1581 1582DEFAULT_TYPELOC_IMPL(Complex, Type) 1583DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType) 1584DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType) 1585DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType) 1586DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType) 1587DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type) 1588DEFAULT_TYPELOC_IMPL(Vector, Type) 1589DEFAULT_TYPELOC_IMPL(ExtVector, VectorType) 1590DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType) 1591DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType) 1592DEFAULT_TYPELOC_IMPL(Record, TagType) 1593DEFAULT_TYPELOC_IMPL(Enum, TagType) 1594DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type) 1595DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type) 1596DEFAULT_TYPELOC_IMPL(Auto, Type) 1597 1598bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) { 1599 // Visit the nested-name-specifier, if present. 1600 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1601 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1602 return true; 1603 1604 if (D->isCompleteDefinition()) { 1605 for (CXXRecordDecl::base_class_iterator I = D->bases_begin(), 1606 E = D->bases_end(); I != E; ++I) { 1607 if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(I, TU))) 1608 return true; 1609 } 1610 } 1611 1612 return VisitTagDecl(D); 1613} 1614 1615bool CursorVisitor::VisitAttributes(Decl *D) { 1616 for (AttrVec::const_iterator i = D->attr_begin(), e = D->attr_end(); 1617 i != e; ++i) 1618 if (Visit(MakeCXCursor(*i, D, TU))) 1619 return true; 1620 1621 return false; 1622} 1623 1624//===----------------------------------------------------------------------===// 1625// Data-recursive visitor methods. 1626//===----------------------------------------------------------------------===// 1627 1628namespace { 1629#define DEF_JOB(NAME, DATA, KIND)\ 1630class NAME : public VisitorJob {\ 1631public:\ 1632 NAME(DATA *d, CXCursor parent) : VisitorJob(parent, VisitorJob::KIND, d) {} \ 1633 static bool classof(const VisitorJob *VJ) { return VJ->getKind() == KIND; }\ 1634 DATA *get() const { return static_cast<DATA*>(data[0]); }\ 1635}; 1636 1637DEF_JOB(StmtVisit, Stmt, StmtVisitKind) 1638DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind) 1639DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind) 1640DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind) 1641DEF_JOB(ExplicitTemplateArgsVisit, ASTTemplateArgumentListInfo, 1642 ExplicitTemplateArgsVisitKind) 1643DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind) 1644DEF_JOB(LambdaExprParts, LambdaExpr, LambdaExprPartsKind) 1645DEF_JOB(PostChildrenVisit, void, PostChildrenVisitKind) 1646#undef DEF_JOB 1647 1648class DeclVisit : public VisitorJob { 1649public: 1650 DeclVisit(Decl *d, CXCursor parent, bool isFirst) : 1651 VisitorJob(parent, VisitorJob::DeclVisitKind, 1652 d, isFirst ? (void*) 1 : (void*) 0) {} 1653 static bool classof(const VisitorJob *VJ) { 1654 return VJ->getKind() == DeclVisitKind; 1655 } 1656 Decl *get() const { return static_cast<Decl*>(data[0]); } 1657 bool isFirst() const { return data[1] ? true : false; } 1658}; 1659class TypeLocVisit : public VisitorJob { 1660public: 1661 TypeLocVisit(TypeLoc tl, CXCursor parent) : 1662 VisitorJob(parent, VisitorJob::TypeLocVisitKind, 1663 tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {} 1664 1665 static bool classof(const VisitorJob *VJ) { 1666 return VJ->getKind() == TypeLocVisitKind; 1667 } 1668 1669 TypeLoc get() const { 1670 QualType T = QualType::getFromOpaquePtr(data[0]); 1671 return TypeLoc(T, data[1]); 1672 } 1673}; 1674 1675class LabelRefVisit : public VisitorJob { 1676public: 1677 LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent) 1678 : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD, 1679 labelLoc.getPtrEncoding()) {} 1680 1681 static bool classof(const VisitorJob *VJ) { 1682 return VJ->getKind() == VisitorJob::LabelRefVisitKind; 1683 } 1684 LabelDecl *get() const { return static_cast<LabelDecl*>(data[0]); } 1685 SourceLocation getLoc() const { 1686 return SourceLocation::getFromPtrEncoding(data[1]); } 1687}; 1688 1689class NestedNameSpecifierLocVisit : public VisitorJob { 1690public: 1691 NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent) 1692 : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind, 1693 Qualifier.getNestedNameSpecifier(), 1694 Qualifier.getOpaqueData()) { } 1695 1696 static bool classof(const VisitorJob *VJ) { 1697 return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind; 1698 } 1699 1700 NestedNameSpecifierLoc get() const { 1701 return NestedNameSpecifierLoc(static_cast<NestedNameSpecifier*>(data[0]), 1702 data[1]); 1703 } 1704}; 1705 1706class DeclarationNameInfoVisit : public VisitorJob { 1707public: 1708 DeclarationNameInfoVisit(Stmt *S, CXCursor parent) 1709 : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {} 1710 static bool classof(const VisitorJob *VJ) { 1711 return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind; 1712 } 1713 DeclarationNameInfo get() const { 1714 Stmt *S = static_cast<Stmt*>(data[0]); 1715 switch (S->getStmtClass()) { 1716 default: 1717 llvm_unreachable("Unhandled Stmt"); 1718 case clang::Stmt::MSDependentExistsStmtClass: 1719 return cast<MSDependentExistsStmt>(S)->getNameInfo(); 1720 case Stmt::CXXDependentScopeMemberExprClass: 1721 return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo(); 1722 case Stmt::DependentScopeDeclRefExprClass: 1723 return cast<DependentScopeDeclRefExpr>(S)->getNameInfo(); 1724 } 1725 } 1726}; 1727class MemberRefVisit : public VisitorJob { 1728public: 1729 MemberRefVisit(FieldDecl *D, SourceLocation L, CXCursor parent) 1730 : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D, 1731 L.getPtrEncoding()) {} 1732 static bool classof(const VisitorJob *VJ) { 1733 return VJ->getKind() == VisitorJob::MemberRefVisitKind; 1734 } 1735 FieldDecl *get() const { 1736 return static_cast<FieldDecl*>(data[0]); 1737 } 1738 SourceLocation getLoc() const { 1739 return SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[1]); 1740 } 1741}; 1742class EnqueueVisitor : public StmtVisitor<EnqueueVisitor, void> { 1743 VisitorWorkList &WL; 1744 CXCursor Parent; 1745public: 1746 EnqueueVisitor(VisitorWorkList &wl, CXCursor parent) 1747 : WL(wl), Parent(parent) {} 1748 1749 void VisitAddrLabelExpr(AddrLabelExpr *E); 1750 void VisitBlockExpr(BlockExpr *B); 1751 void VisitCompoundLiteralExpr(CompoundLiteralExpr *E); 1752 void VisitCompoundStmt(CompoundStmt *S); 1753 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { /* Do nothing. */ } 1754 void VisitMSDependentExistsStmt(MSDependentExistsStmt *S); 1755 void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E); 1756 void VisitCXXNewExpr(CXXNewExpr *E); 1757 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E); 1758 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E); 1759 void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E); 1760 void VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E); 1761 void VisitCXXTypeidExpr(CXXTypeidExpr *E); 1762 void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E); 1763 void VisitCXXUuidofExpr(CXXUuidofExpr *E); 1764 void VisitCXXCatchStmt(CXXCatchStmt *S); 1765 void VisitDeclRefExpr(DeclRefExpr *D); 1766 void VisitDeclStmt(DeclStmt *S); 1767 void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E); 1768 void VisitDesignatedInitExpr(DesignatedInitExpr *E); 1769 void VisitExplicitCastExpr(ExplicitCastExpr *E); 1770 void VisitForStmt(ForStmt *FS); 1771 void VisitGotoStmt(GotoStmt *GS); 1772 void VisitIfStmt(IfStmt *If); 1773 void VisitInitListExpr(InitListExpr *IE); 1774 void VisitMemberExpr(MemberExpr *M); 1775 void VisitOffsetOfExpr(OffsetOfExpr *E); 1776 void VisitObjCEncodeExpr(ObjCEncodeExpr *E); 1777 void VisitObjCMessageExpr(ObjCMessageExpr *M); 1778 void VisitOverloadExpr(OverloadExpr *E); 1779 void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E); 1780 void VisitStmt(Stmt *S); 1781 void VisitSwitchStmt(SwitchStmt *S); 1782 void VisitWhileStmt(WhileStmt *W); 1783 void VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E); 1784 void VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E); 1785 void VisitTypeTraitExpr(TypeTraitExpr *E); 1786 void VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E); 1787 void VisitExpressionTraitExpr(ExpressionTraitExpr *E); 1788 void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *U); 1789 void VisitVAArgExpr(VAArgExpr *E); 1790 void VisitSizeOfPackExpr(SizeOfPackExpr *E); 1791 void VisitPseudoObjectExpr(PseudoObjectExpr *E); 1792 void VisitOpaqueValueExpr(OpaqueValueExpr *E); 1793 void VisitLambdaExpr(LambdaExpr *E); 1794 1795private: 1796 void AddDeclarationNameInfo(Stmt *S); 1797 void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier); 1798 void AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A); 1799 void AddMemberRef(FieldDecl *D, SourceLocation L); 1800 void AddStmt(Stmt *S); 1801 void AddDecl(Decl *D, bool isFirst = true); 1802 void AddTypeLoc(TypeSourceInfo *TI); 1803 void EnqueueChildren(Stmt *S); 1804}; 1805} // end anonyous namespace 1806 1807void EnqueueVisitor::AddDeclarationNameInfo(Stmt *S) { 1808 // 'S' should always be non-null, since it comes from the 1809 // statement we are visiting. 1810 WL.push_back(DeclarationNameInfoVisit(S, Parent)); 1811} 1812 1813void 1814EnqueueVisitor::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) { 1815 if (Qualifier) 1816 WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent)); 1817} 1818 1819void EnqueueVisitor::AddStmt(Stmt *S) { 1820 if (S) 1821 WL.push_back(StmtVisit(S, Parent)); 1822} 1823void EnqueueVisitor::AddDecl(Decl *D, bool isFirst) { 1824 if (D) 1825 WL.push_back(DeclVisit(D, Parent, isFirst)); 1826} 1827void EnqueueVisitor:: 1828 AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A) { 1829 if (A) 1830 WL.push_back(ExplicitTemplateArgsVisit( 1831 const_cast<ASTTemplateArgumentListInfo*>(A), Parent)); 1832} 1833void EnqueueVisitor::AddMemberRef(FieldDecl *D, SourceLocation L) { 1834 if (D) 1835 WL.push_back(MemberRefVisit(D, L, Parent)); 1836} 1837void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) { 1838 if (TI) 1839 WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent)); 1840 } 1841void EnqueueVisitor::EnqueueChildren(Stmt *S) { 1842 unsigned size = WL.size(); 1843 for (Stmt::child_range Child = S->children(); Child; ++Child) { 1844 AddStmt(*Child); 1845 } 1846 if (size == WL.size()) 1847 return; 1848 // Now reverse the entries we just added. This will match the DFS 1849 // ordering performed by the worklist. 1850 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 1851 std::reverse(I, E); 1852} 1853void EnqueueVisitor::VisitAddrLabelExpr(AddrLabelExpr *E) { 1854 WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent)); 1855} 1856void EnqueueVisitor::VisitBlockExpr(BlockExpr *B) { 1857 AddDecl(B->getBlockDecl()); 1858} 1859void EnqueueVisitor::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 1860 EnqueueChildren(E); 1861 AddTypeLoc(E->getTypeSourceInfo()); 1862} 1863void EnqueueVisitor::VisitCompoundStmt(CompoundStmt *S) { 1864 for (CompoundStmt::reverse_body_iterator I = S->body_rbegin(), 1865 E = S->body_rend(); I != E; ++I) { 1866 AddStmt(*I); 1867 } 1868} 1869void EnqueueVisitor:: 1870VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { 1871 AddStmt(S->getSubStmt()); 1872 AddDeclarationNameInfo(S); 1873 if (NestedNameSpecifierLoc QualifierLoc = S->getQualifierLoc()) 1874 AddNestedNameSpecifierLoc(QualifierLoc); 1875} 1876 1877void EnqueueVisitor:: 1878VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) { 1879 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 1880 AddDeclarationNameInfo(E); 1881 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 1882 AddNestedNameSpecifierLoc(QualifierLoc); 1883 if (!E->isImplicitAccess()) 1884 AddStmt(E->getBase()); 1885} 1886void EnqueueVisitor::VisitCXXNewExpr(CXXNewExpr *E) { 1887 // Enqueue the initializer , if any. 1888 AddStmt(E->getInitializer()); 1889 // Enqueue the array size, if any. 1890 AddStmt(E->getArraySize()); 1891 // Enqueue the allocated type. 1892 AddTypeLoc(E->getAllocatedTypeSourceInfo()); 1893 // Enqueue the placement arguments. 1894 for (unsigned I = E->getNumPlacementArgs(); I > 0; --I) 1895 AddStmt(E->getPlacementArg(I-1)); 1896} 1897void EnqueueVisitor::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *CE) { 1898 for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I) 1899 AddStmt(CE->getArg(I-1)); 1900 AddStmt(CE->getCallee()); 1901 AddStmt(CE->getArg(0)); 1902} 1903void EnqueueVisitor::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 1904 // Visit the name of the type being destroyed. 1905 AddTypeLoc(E->getDestroyedTypeInfo()); 1906 // Visit the scope type that looks disturbingly like the nested-name-specifier 1907 // but isn't. 1908 AddTypeLoc(E->getScopeTypeInfo()); 1909 // Visit the nested-name-specifier. 1910 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 1911 AddNestedNameSpecifierLoc(QualifierLoc); 1912 // Visit base expression. 1913 AddStmt(E->getBase()); 1914} 1915void EnqueueVisitor::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 1916 AddTypeLoc(E->getTypeSourceInfo()); 1917} 1918void EnqueueVisitor::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 1919 EnqueueChildren(E); 1920 AddTypeLoc(E->getTypeSourceInfo()); 1921} 1922void EnqueueVisitor::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 1923 EnqueueChildren(E); 1924 if (E->isTypeOperand()) 1925 AddTypeLoc(E->getTypeOperandSourceInfo()); 1926} 1927 1928void EnqueueVisitor::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr 1929 *E) { 1930 EnqueueChildren(E); 1931 AddTypeLoc(E->getTypeSourceInfo()); 1932} 1933void EnqueueVisitor::VisitCXXUuidofExpr(CXXUuidofExpr *E) { 1934 EnqueueChildren(E); 1935 if (E->isTypeOperand()) 1936 AddTypeLoc(E->getTypeOperandSourceInfo()); 1937} 1938 1939void EnqueueVisitor::VisitCXXCatchStmt(CXXCatchStmt *S) { 1940 EnqueueChildren(S); 1941 AddDecl(S->getExceptionDecl()); 1942} 1943 1944void EnqueueVisitor::VisitDeclRefExpr(DeclRefExpr *DR) { 1945 if (DR->hasExplicitTemplateArgs()) { 1946 AddExplicitTemplateArgs(&DR->getExplicitTemplateArgs()); 1947 } 1948 WL.push_back(DeclRefExprParts(DR, Parent)); 1949} 1950void EnqueueVisitor::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 1951 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 1952 AddDeclarationNameInfo(E); 1953 AddNestedNameSpecifierLoc(E->getQualifierLoc()); 1954} 1955void EnqueueVisitor::VisitDeclStmt(DeclStmt *S) { 1956 unsigned size = WL.size(); 1957 bool isFirst = true; 1958 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 1959 D != DEnd; ++D) { 1960 AddDecl(*D, isFirst); 1961 isFirst = false; 1962 } 1963 if (size == WL.size()) 1964 return; 1965 // Now reverse the entries we just added. This will match the DFS 1966 // ordering performed by the worklist. 1967 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 1968 std::reverse(I, E); 1969} 1970void EnqueueVisitor::VisitDesignatedInitExpr(DesignatedInitExpr *E) { 1971 AddStmt(E->getInit()); 1972 typedef DesignatedInitExpr::Designator Designator; 1973 for (DesignatedInitExpr::reverse_designators_iterator 1974 D = E->designators_rbegin(), DEnd = E->designators_rend(); 1975 D != DEnd; ++D) { 1976 if (D->isFieldDesignator()) { 1977 if (FieldDecl *Field = D->getField()) 1978 AddMemberRef(Field, D->getFieldLoc()); 1979 continue; 1980 } 1981 if (D->isArrayDesignator()) { 1982 AddStmt(E->getArrayIndex(*D)); 1983 continue; 1984 } 1985 assert(D->isArrayRangeDesignator() && "Unknown designator kind"); 1986 AddStmt(E->getArrayRangeEnd(*D)); 1987 AddStmt(E->getArrayRangeStart(*D)); 1988 } 1989} 1990void EnqueueVisitor::VisitExplicitCastExpr(ExplicitCastExpr *E) { 1991 EnqueueChildren(E); 1992 AddTypeLoc(E->getTypeInfoAsWritten()); 1993} 1994void EnqueueVisitor::VisitForStmt(ForStmt *FS) { 1995 AddStmt(FS->getBody()); 1996 AddStmt(FS->getInc()); 1997 AddStmt(FS->getCond()); 1998 AddDecl(FS->getConditionVariable()); 1999 AddStmt(FS->getInit()); 2000} 2001void EnqueueVisitor::VisitGotoStmt(GotoStmt *GS) { 2002 WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent)); 2003} 2004void EnqueueVisitor::VisitIfStmt(IfStmt *If) { 2005 AddStmt(If->getElse()); 2006 AddStmt(If->getThen()); 2007 AddStmt(If->getCond()); 2008 AddDecl(If->getConditionVariable()); 2009} 2010void EnqueueVisitor::VisitInitListExpr(InitListExpr *IE) { 2011 // We care about the syntactic form of the initializer list, only. 2012 if (InitListExpr *Syntactic = IE->getSyntacticForm()) 2013 IE = Syntactic; 2014 EnqueueChildren(IE); 2015} 2016void EnqueueVisitor::VisitMemberExpr(MemberExpr *M) { 2017 WL.push_back(MemberExprParts(M, Parent)); 2018 2019 // If the base of the member access expression is an implicit 'this', don't 2020 // visit it. 2021 // FIXME: If we ever want to show these implicit accesses, this will be 2022 // unfortunate. However, clang_getCursor() relies on this behavior. 2023 if (!M->isImplicitAccess()) 2024 AddStmt(M->getBase()); 2025} 2026void EnqueueVisitor::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 2027 AddTypeLoc(E->getEncodedTypeSourceInfo()); 2028} 2029void EnqueueVisitor::VisitObjCMessageExpr(ObjCMessageExpr *M) { 2030 EnqueueChildren(M); 2031 AddTypeLoc(M->getClassReceiverTypeInfo()); 2032} 2033void EnqueueVisitor::VisitOffsetOfExpr(OffsetOfExpr *E) { 2034 // Visit the components of the offsetof expression. 2035 for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) { 2036 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode; 2037 const OffsetOfNode &Node = E->getComponent(I-1); 2038 switch (Node.getKind()) { 2039 case OffsetOfNode::Array: 2040 AddStmt(E->getIndexExpr(Node.getArrayExprIndex())); 2041 break; 2042 case OffsetOfNode::Field: 2043 AddMemberRef(Node.getField(), Node.getSourceRange().getEnd()); 2044 break; 2045 case OffsetOfNode::Identifier: 2046 case OffsetOfNode::Base: 2047 continue; 2048 } 2049 } 2050 // Visit the type into which we're computing the offset. 2051 AddTypeLoc(E->getTypeSourceInfo()); 2052} 2053void EnqueueVisitor::VisitOverloadExpr(OverloadExpr *E) { 2054 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 2055 WL.push_back(OverloadExprParts(E, Parent)); 2056} 2057void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr( 2058 UnaryExprOrTypeTraitExpr *E) { 2059 EnqueueChildren(E); 2060 if (E->isArgumentType()) 2061 AddTypeLoc(E->getArgumentTypeInfo()); 2062} 2063void EnqueueVisitor::VisitStmt(Stmt *S) { 2064 EnqueueChildren(S); 2065} 2066void EnqueueVisitor::VisitSwitchStmt(SwitchStmt *S) { 2067 AddStmt(S->getBody()); 2068 AddStmt(S->getCond()); 2069 AddDecl(S->getConditionVariable()); 2070} 2071 2072void EnqueueVisitor::VisitWhileStmt(WhileStmt *W) { 2073 AddStmt(W->getBody()); 2074 AddStmt(W->getCond()); 2075 AddDecl(W->getConditionVariable()); 2076} 2077 2078void EnqueueVisitor::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 2079 AddTypeLoc(E->getQueriedTypeSourceInfo()); 2080} 2081 2082void EnqueueVisitor::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { 2083 AddTypeLoc(E->getRhsTypeSourceInfo()); 2084 AddTypeLoc(E->getLhsTypeSourceInfo()); 2085} 2086 2087void EnqueueVisitor::VisitTypeTraitExpr(TypeTraitExpr *E) { 2088 for (unsigned I = E->getNumArgs(); I > 0; --I) 2089 AddTypeLoc(E->getArg(I-1)); 2090} 2091 2092void EnqueueVisitor::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 2093 AddTypeLoc(E->getQueriedTypeSourceInfo()); 2094} 2095 2096void EnqueueVisitor::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 2097 EnqueueChildren(E); 2098} 2099 2100void EnqueueVisitor::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *U) { 2101 VisitOverloadExpr(U); 2102 if (!U->isImplicitAccess()) 2103 AddStmt(U->getBase()); 2104} 2105void EnqueueVisitor::VisitVAArgExpr(VAArgExpr *E) { 2106 AddStmt(E->getSubExpr()); 2107 AddTypeLoc(E->getWrittenTypeInfo()); 2108} 2109void EnqueueVisitor::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 2110 WL.push_back(SizeOfPackExprParts(E, Parent)); 2111} 2112void EnqueueVisitor::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 2113 // If the opaque value has a source expression, just transparently 2114 // visit that. This is useful for (e.g.) pseudo-object expressions. 2115 if (Expr *SourceExpr = E->getSourceExpr()) 2116 return Visit(SourceExpr); 2117} 2118void EnqueueVisitor::VisitLambdaExpr(LambdaExpr *E) { 2119 AddStmt(E->getBody()); 2120 WL.push_back(LambdaExprParts(E, Parent)); 2121} 2122void EnqueueVisitor::VisitPseudoObjectExpr(PseudoObjectExpr *E) { 2123 // Treat the expression like its syntactic form. 2124 Visit(E->getSyntacticForm()); 2125} 2126 2127void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, Stmt *S) { 2128 EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S); 2129} 2130 2131bool CursorVisitor::IsInRegionOfInterest(CXCursor C) { 2132 if (RegionOfInterest.isValid()) { 2133 SourceRange Range = getRawCursorExtent(C); 2134 if (Range.isInvalid() || CompareRegionOfInterest(Range)) 2135 return false; 2136 } 2137 return true; 2138} 2139 2140bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) { 2141 while (!WL.empty()) { 2142 // Dequeue the worklist item. 2143 VisitorJob LI = WL.back(); 2144 WL.pop_back(); 2145 2146 // Set the Parent field, then back to its old value once we're done. 2147 SetParentRAII SetParent(Parent, StmtParent, LI.getParent()); 2148 2149 switch (LI.getKind()) { 2150 case VisitorJob::DeclVisitKind: { 2151 Decl *D = cast<DeclVisit>(&LI)->get(); 2152 if (!D) 2153 continue; 2154 2155 // For now, perform default visitation for Decls. 2156 if (Visit(MakeCXCursor(D, TU, RegionOfInterest, 2157 cast<DeclVisit>(&LI)->isFirst()))) 2158 return true; 2159 2160 continue; 2161 } 2162 case VisitorJob::ExplicitTemplateArgsVisitKind: { 2163 const ASTTemplateArgumentListInfo *ArgList = 2164 cast<ExplicitTemplateArgsVisit>(&LI)->get(); 2165 for (const TemplateArgumentLoc *Arg = ArgList->getTemplateArgs(), 2166 *ArgEnd = Arg + ArgList->NumTemplateArgs; 2167 Arg != ArgEnd; ++Arg) { 2168 if (VisitTemplateArgumentLoc(*Arg)) 2169 return true; 2170 } 2171 continue; 2172 } 2173 case VisitorJob::TypeLocVisitKind: { 2174 // Perform default visitation for TypeLocs. 2175 if (Visit(cast<TypeLocVisit>(&LI)->get())) 2176 return true; 2177 continue; 2178 } 2179 case VisitorJob::LabelRefVisitKind: { 2180 LabelDecl *LS = cast<LabelRefVisit>(&LI)->get(); 2181 if (LabelStmt *stmt = LS->getStmt()) { 2182 if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(), 2183 TU))) { 2184 return true; 2185 } 2186 } 2187 continue; 2188 } 2189 2190 case VisitorJob::NestedNameSpecifierLocVisitKind: { 2191 NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI); 2192 if (VisitNestedNameSpecifierLoc(V->get())) 2193 return true; 2194 continue; 2195 } 2196 2197 case VisitorJob::DeclarationNameInfoVisitKind: { 2198 if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI) 2199 ->get())) 2200 return true; 2201 continue; 2202 } 2203 case VisitorJob::MemberRefVisitKind: { 2204 MemberRefVisit *V = cast<MemberRefVisit>(&LI); 2205 if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU))) 2206 return true; 2207 continue; 2208 } 2209 case VisitorJob::StmtVisitKind: { 2210 Stmt *S = cast<StmtVisit>(&LI)->get(); 2211 if (!S) 2212 continue; 2213 2214 // Update the current cursor. 2215 CXCursor Cursor = MakeCXCursor(S, StmtParent, TU, RegionOfInterest); 2216 if (!IsInRegionOfInterest(Cursor)) 2217 continue; 2218 switch (Visitor(Cursor, Parent, ClientData)) { 2219 case CXChildVisit_Break: return true; 2220 case CXChildVisit_Continue: break; 2221 case CXChildVisit_Recurse: 2222 if (PostChildrenVisitor) 2223 WL.push_back(PostChildrenVisit(0, Cursor)); 2224 EnqueueWorkList(WL, S); 2225 break; 2226 } 2227 continue; 2228 } 2229 case VisitorJob::MemberExprPartsKind: { 2230 // Handle the other pieces in the MemberExpr besides the base. 2231 MemberExpr *M = cast<MemberExprParts>(&LI)->get(); 2232 2233 // Visit the nested-name-specifier 2234 if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc()) 2235 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2236 return true; 2237 2238 // Visit the declaration name. 2239 if (VisitDeclarationNameInfo(M->getMemberNameInfo())) 2240 return true; 2241 2242 // Visit the explicitly-specified template arguments, if any. 2243 if (M->hasExplicitTemplateArgs()) { 2244 for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(), 2245 *ArgEnd = Arg + M->getNumTemplateArgs(); 2246 Arg != ArgEnd; ++Arg) { 2247 if (VisitTemplateArgumentLoc(*Arg)) 2248 return true; 2249 } 2250 } 2251 continue; 2252 } 2253 case VisitorJob::DeclRefExprPartsKind: { 2254 DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get(); 2255 // Visit nested-name-specifier, if present. 2256 if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc()) 2257 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2258 return true; 2259 // Visit declaration name. 2260 if (VisitDeclarationNameInfo(DR->getNameInfo())) 2261 return true; 2262 continue; 2263 } 2264 case VisitorJob::OverloadExprPartsKind: { 2265 OverloadExpr *O = cast<OverloadExprParts>(&LI)->get(); 2266 // Visit the nested-name-specifier. 2267 if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc()) 2268 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2269 return true; 2270 // Visit the declaration name. 2271 if (VisitDeclarationNameInfo(O->getNameInfo())) 2272 return true; 2273 // Visit the overloaded declaration reference. 2274 if (Visit(MakeCursorOverloadedDeclRef(O, TU))) 2275 return true; 2276 continue; 2277 } 2278 case VisitorJob::SizeOfPackExprPartsKind: { 2279 SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get(); 2280 NamedDecl *Pack = E->getPack(); 2281 if (isa<TemplateTypeParmDecl>(Pack)) { 2282 if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack), 2283 E->getPackLoc(), TU))) 2284 return true; 2285 2286 continue; 2287 } 2288 2289 if (isa<TemplateTemplateParmDecl>(Pack)) { 2290 if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack), 2291 E->getPackLoc(), TU))) 2292 return true; 2293 2294 continue; 2295 } 2296 2297 // Non-type template parameter packs and function parameter packs are 2298 // treated like DeclRefExpr cursors. 2299 continue; 2300 } 2301 2302 case VisitorJob::LambdaExprPartsKind: { 2303 // Visit captures. 2304 LambdaExpr *E = cast<LambdaExprParts>(&LI)->get(); 2305 for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(), 2306 CEnd = E->explicit_capture_end(); 2307 C != CEnd; ++C) { 2308 if (C->capturesThis()) 2309 continue; 2310 2311 if (Visit(MakeCursorVariableRef(C->getCapturedVar(), 2312 C->getLocation(), 2313 TU))) 2314 return true; 2315 } 2316 2317 // Visit parameters and return type, if present. 2318 if (E->hasExplicitParameters() || E->hasExplicitResultType()) { 2319 TypeLoc TL = E->getCallOperator()->getTypeSourceInfo()->getTypeLoc(); 2320 if (E->hasExplicitParameters() && E->hasExplicitResultType()) { 2321 // Visit the whole type. 2322 if (Visit(TL)) 2323 return true; 2324 } else if (isa<FunctionProtoTypeLoc>(TL)) { 2325 FunctionProtoTypeLoc Proto = cast<FunctionProtoTypeLoc>(TL); 2326 if (E->hasExplicitParameters()) { 2327 // Visit parameters. 2328 for (unsigned I = 0, N = Proto.getNumArgs(); I != N; ++I) 2329 if (Visit(MakeCXCursor(Proto.getArg(I), TU))) 2330 return true; 2331 } else { 2332 // Visit result type. 2333 if (Visit(Proto.getResultLoc())) 2334 return true; 2335 } 2336 } 2337 } 2338 break; 2339 } 2340 2341 case VisitorJob::PostChildrenVisitKind: 2342 if (PostChildrenVisitor(Parent, ClientData)) 2343 return true; 2344 break; 2345 } 2346 } 2347 return false; 2348} 2349 2350bool CursorVisitor::Visit(Stmt *S) { 2351 VisitorWorkList *WL = 0; 2352 if (!WorkListFreeList.empty()) { 2353 WL = WorkListFreeList.back(); 2354 WL->clear(); 2355 WorkListFreeList.pop_back(); 2356 } 2357 else { 2358 WL = new VisitorWorkList(); 2359 WorkListCache.push_back(WL); 2360 } 2361 EnqueueWorkList(*WL, S); 2362 bool result = RunVisitorWorkList(*WL); 2363 WorkListFreeList.push_back(WL); 2364 return result; 2365} 2366 2367namespace { 2368typedef llvm::SmallVector<SourceRange, 4> RefNamePieces; 2369RefNamePieces buildPieces(unsigned NameFlags, bool IsMemberRefExpr, 2370 const DeclarationNameInfo &NI, 2371 const SourceRange &QLoc, 2372 const ASTTemplateArgumentListInfo *TemplateArgs = 0){ 2373 const bool WantQualifier = NameFlags & CXNameRange_WantQualifier; 2374 const bool WantTemplateArgs = NameFlags & CXNameRange_WantTemplateArgs; 2375 const bool WantSinglePiece = NameFlags & CXNameRange_WantSinglePiece; 2376 2377 const DeclarationName::NameKind Kind = NI.getName().getNameKind(); 2378 2379 RefNamePieces Pieces; 2380 2381 if (WantQualifier && QLoc.isValid()) 2382 Pieces.push_back(QLoc); 2383 2384 if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr) 2385 Pieces.push_back(NI.getLoc()); 2386 2387 if (WantTemplateArgs && TemplateArgs) 2388 Pieces.push_back(SourceRange(TemplateArgs->LAngleLoc, 2389 TemplateArgs->RAngleLoc)); 2390 2391 if (Kind == DeclarationName::CXXOperatorName) { 2392 Pieces.push_back(SourceLocation::getFromRawEncoding( 2393 NI.getInfo().CXXOperatorName.BeginOpNameLoc)); 2394 Pieces.push_back(SourceLocation::getFromRawEncoding( 2395 NI.getInfo().CXXOperatorName.EndOpNameLoc)); 2396 } 2397 2398 if (WantSinglePiece) { 2399 SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd()); 2400 Pieces.clear(); 2401 Pieces.push_back(R); 2402 } 2403 2404 return Pieces; 2405} 2406} 2407 2408//===----------------------------------------------------------------------===// 2409// Misc. API hooks. 2410//===----------------------------------------------------------------------===// 2411 2412static llvm::sys::Mutex EnableMultithreadingMutex; 2413static bool EnabledMultithreading; 2414 2415static void fatal_error_handler(void *user_data, const std::string& reason) { 2416 // Write the result out to stderr avoiding errs() because raw_ostreams can 2417 // call report_fatal_error. 2418 fprintf(stderr, "LIBCLANG FATAL ERROR: %s\n", reason.c_str()); 2419 ::abort(); 2420} 2421 2422extern "C" { 2423CXIndex clang_createIndex(int excludeDeclarationsFromPCH, 2424 int displayDiagnostics) { 2425 // Disable pretty stack trace functionality, which will otherwise be a very 2426 // poor citizen of the world and set up all sorts of signal handlers. 2427 llvm::DisablePrettyStackTrace = true; 2428 2429 // We use crash recovery to make some of our APIs more reliable, implicitly 2430 // enable it. 2431 llvm::CrashRecoveryContext::Enable(); 2432 2433 // Enable support for multithreading in LLVM. 2434 { 2435 llvm::sys::ScopedLock L(EnableMultithreadingMutex); 2436 if (!EnabledMultithreading) { 2437 llvm::install_fatal_error_handler(fatal_error_handler, 0); 2438 llvm::llvm_start_multithreaded(); 2439 EnabledMultithreading = true; 2440 } 2441 } 2442 2443 CIndexer *CIdxr = new CIndexer(); 2444 if (excludeDeclarationsFromPCH) 2445 CIdxr->setOnlyLocalDecls(); 2446 if (displayDiagnostics) 2447 CIdxr->setDisplayDiagnostics(); 2448 2449 if (getenv("LIBCLANG_BGPRIO_INDEX")) 2450 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() | 2451 CXGlobalOpt_ThreadBackgroundPriorityForIndexing); 2452 if (getenv("LIBCLANG_BGPRIO_EDIT")) 2453 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() | 2454 CXGlobalOpt_ThreadBackgroundPriorityForEditing); 2455 2456 return CIdxr; 2457} 2458 2459void clang_disposeIndex(CXIndex CIdx) { 2460 if (CIdx) 2461 delete static_cast<CIndexer *>(CIdx); 2462} 2463 2464void clang_CXIndex_setGlobalOptions(CXIndex CIdx, unsigned options) { 2465 if (CIdx) 2466 static_cast<CIndexer *>(CIdx)->setCXGlobalOptFlags(options); 2467} 2468 2469unsigned clang_CXIndex_getGlobalOptions(CXIndex CIdx) { 2470 if (CIdx) 2471 return static_cast<CIndexer *>(CIdx)->getCXGlobalOptFlags(); 2472 return 0; 2473} 2474 2475void clang_toggleCrashRecovery(unsigned isEnabled) { 2476 if (isEnabled) 2477 llvm::CrashRecoveryContext::Enable(); 2478 else 2479 llvm::CrashRecoveryContext::Disable(); 2480} 2481 2482CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx, 2483 const char *ast_filename) { 2484 if (!CIdx) 2485 return 0; 2486 2487 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 2488 FileSystemOptions FileSystemOpts; 2489 FileSystemOpts.WorkingDir = CXXIdx->getWorkingDirectory(); 2490 2491 IntrusiveRefCntPtr<DiagnosticsEngine> Diags; 2492 ASTUnit *TU = ASTUnit::LoadFromASTFile(ast_filename, Diags, FileSystemOpts, 2493 CXXIdx->getOnlyLocalDecls(), 2494 0, 0, 2495 /*CaptureDiagnostics=*/true, 2496 /*AllowPCHWithCompilerErrors=*/true, 2497 /*UserFilesAreVolatile=*/true); 2498 return MakeCXTranslationUnit(CXXIdx, TU); 2499} 2500 2501unsigned clang_defaultEditingTranslationUnitOptions() { 2502 return CXTranslationUnit_PrecompiledPreamble | 2503 CXTranslationUnit_CacheCompletionResults; 2504} 2505 2506CXTranslationUnit 2507clang_createTranslationUnitFromSourceFile(CXIndex CIdx, 2508 const char *source_filename, 2509 int num_command_line_args, 2510 const char * const *command_line_args, 2511 unsigned num_unsaved_files, 2512 struct CXUnsavedFile *unsaved_files) { 2513 unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord; 2514 return clang_parseTranslationUnit(CIdx, source_filename, 2515 command_line_args, num_command_line_args, 2516 unsaved_files, num_unsaved_files, 2517 Options); 2518} 2519 2520struct ParseTranslationUnitInfo { 2521 CXIndex CIdx; 2522 const char *source_filename; 2523 const char *const *command_line_args; 2524 int num_command_line_args; 2525 struct CXUnsavedFile *unsaved_files; 2526 unsigned num_unsaved_files; 2527 unsigned options; 2528 CXTranslationUnit result; 2529}; 2530static void clang_parseTranslationUnit_Impl(void *UserData) { 2531 ParseTranslationUnitInfo *PTUI = 2532 static_cast<ParseTranslationUnitInfo*>(UserData); 2533 CXIndex CIdx = PTUI->CIdx; 2534 const char *source_filename = PTUI->source_filename; 2535 const char * const *command_line_args = PTUI->command_line_args; 2536 int num_command_line_args = PTUI->num_command_line_args; 2537 struct CXUnsavedFile *unsaved_files = PTUI->unsaved_files; 2538 unsigned num_unsaved_files = PTUI->num_unsaved_files; 2539 unsigned options = PTUI->options; 2540 PTUI->result = 0; 2541 2542 if (!CIdx) 2543 return; 2544 2545 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 2546 2547 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing)) 2548 setThreadBackgroundPriority(); 2549 2550 bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble; 2551 // FIXME: Add a flag for modules. 2552 TranslationUnitKind TUKind 2553 = (options & CXTranslationUnit_Incomplete)? TU_Prefix : TU_Complete; 2554 bool CacheCodeCompetionResults 2555 = options & CXTranslationUnit_CacheCompletionResults; 2556 bool IncludeBriefCommentsInCodeCompletion 2557 = options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion; 2558 bool SkipFunctionBodies = options & CXTranslationUnit_SkipFunctionBodies; 2559 bool ForSerialization = options & CXTranslationUnit_ForSerialization; 2560 2561 // Configure the diagnostics. 2562 IntrusiveRefCntPtr<DiagnosticsEngine> 2563 Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions, 2564 num_command_line_args, 2565 command_line_args)); 2566 2567 // Recover resources if we crash before exiting this function. 2568 llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine, 2569 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> > 2570 DiagCleanup(Diags.getPtr()); 2571 2572 OwningPtr<std::vector<ASTUnit::RemappedFile> > 2573 RemappedFiles(new std::vector<ASTUnit::RemappedFile>()); 2574 2575 // Recover resources if we crash before exiting this function. 2576 llvm::CrashRecoveryContextCleanupRegistrar< 2577 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get()); 2578 2579 for (unsigned I = 0; I != num_unsaved_files; ++I) { 2580 StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length); 2581 const llvm::MemoryBuffer *Buffer 2582 = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename); 2583 RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename, 2584 Buffer)); 2585 } 2586 2587 OwningPtr<std::vector<const char *> > 2588 Args(new std::vector<const char*>()); 2589 2590 // Recover resources if we crash before exiting this method. 2591 llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> > 2592 ArgsCleanup(Args.get()); 2593 2594 // Since the Clang C library is primarily used by batch tools dealing with 2595 // (often very broken) source code, where spell-checking can have a 2596 // significant negative impact on performance (particularly when 2597 // precompiled headers are involved), we disable it by default. 2598 // Only do this if we haven't found a spell-checking-related argument. 2599 bool FoundSpellCheckingArgument = false; 2600 for (int I = 0; I != num_command_line_args; ++I) { 2601 if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 || 2602 strcmp(command_line_args[I], "-fspell-checking") == 0) { 2603 FoundSpellCheckingArgument = true; 2604 break; 2605 } 2606 } 2607 if (!FoundSpellCheckingArgument) 2608 Args->push_back("-fno-spell-checking"); 2609 2610 Args->insert(Args->end(), command_line_args, 2611 command_line_args + num_command_line_args); 2612 2613 // The 'source_filename' argument is optional. If the caller does not 2614 // specify it then it is assumed that the source file is specified 2615 // in the actual argument list. 2616 // Put the source file after command_line_args otherwise if '-x' flag is 2617 // present it will be unused. 2618 if (source_filename) 2619 Args->push_back(source_filename); 2620 2621 // Do we need the detailed preprocessing record? 2622 if (options & CXTranslationUnit_DetailedPreprocessingRecord) { 2623 Args->push_back("-Xclang"); 2624 Args->push_back("-detailed-preprocessing-record"); 2625 } 2626 2627 unsigned NumErrors = Diags->getClient()->getNumErrors(); 2628 OwningPtr<ASTUnit> ErrUnit; 2629 OwningPtr<ASTUnit> Unit( 2630 ASTUnit::LoadFromCommandLine(Args->size() ? &(*Args)[0] : 0 2631 /* vector::data() not portable */, 2632 Args->size() ? (&(*Args)[0] + Args->size()) :0, 2633 Diags, 2634 CXXIdx->getClangResourcesPath(), 2635 CXXIdx->getOnlyLocalDecls(), 2636 /*CaptureDiagnostics=*/true, 2637 RemappedFiles->size() ? &(*RemappedFiles)[0]:0, 2638 RemappedFiles->size(), 2639 /*RemappedFilesKeepOriginalName=*/true, 2640 PrecompilePreamble, 2641 TUKind, 2642 CacheCodeCompetionResults, 2643 IncludeBriefCommentsInCodeCompletion, 2644 /*AllowPCHWithCompilerErrors=*/true, 2645 SkipFunctionBodies, 2646 /*UserFilesAreVolatile=*/true, 2647 ForSerialization, 2648 &ErrUnit)); 2649 2650 if (NumErrors != Diags->getClient()->getNumErrors()) { 2651 // Make sure to check that 'Unit' is non-NULL. 2652 if (CXXIdx->getDisplayDiagnostics()) 2653 printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get()); 2654 } 2655 2656 PTUI->result = MakeCXTranslationUnit(CXXIdx, Unit.take()); 2657} 2658CXTranslationUnit clang_parseTranslationUnit(CXIndex CIdx, 2659 const char *source_filename, 2660 const char * const *command_line_args, 2661 int num_command_line_args, 2662 struct CXUnsavedFile *unsaved_files, 2663 unsigned num_unsaved_files, 2664 unsigned options) { 2665 ParseTranslationUnitInfo PTUI = { CIdx, source_filename, command_line_args, 2666 num_command_line_args, unsaved_files, 2667 num_unsaved_files, options, 0 }; 2668 llvm::CrashRecoveryContext CRC; 2669 2670 if (!RunSafely(CRC, clang_parseTranslationUnit_Impl, &PTUI)) { 2671 fprintf(stderr, "libclang: crash detected during parsing: {\n"); 2672 fprintf(stderr, " 'source_filename' : '%s'\n", source_filename); 2673 fprintf(stderr, " 'command_line_args' : ["); 2674 for (int i = 0; i != num_command_line_args; ++i) { 2675 if (i) 2676 fprintf(stderr, ", "); 2677 fprintf(stderr, "'%s'", command_line_args[i]); 2678 } 2679 fprintf(stderr, "],\n"); 2680 fprintf(stderr, " 'unsaved_files' : ["); 2681 for (unsigned i = 0; i != num_unsaved_files; ++i) { 2682 if (i) 2683 fprintf(stderr, ", "); 2684 fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename, 2685 unsaved_files[i].Length); 2686 } 2687 fprintf(stderr, "],\n"); 2688 fprintf(stderr, " 'options' : %d,\n", options); 2689 fprintf(stderr, "}\n"); 2690 2691 return 0; 2692 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) { 2693 PrintLibclangResourceUsage(PTUI.result); 2694 } 2695 2696 return PTUI.result; 2697} 2698 2699unsigned clang_defaultSaveOptions(CXTranslationUnit TU) { 2700 return CXSaveTranslationUnit_None; 2701} 2702 2703namespace { 2704 2705struct SaveTranslationUnitInfo { 2706 CXTranslationUnit TU; 2707 const char *FileName; 2708 unsigned options; 2709 CXSaveError result; 2710}; 2711 2712} 2713 2714static void clang_saveTranslationUnit_Impl(void *UserData) { 2715 SaveTranslationUnitInfo *STUI = 2716 static_cast<SaveTranslationUnitInfo*>(UserData); 2717 2718 CIndexer *CXXIdx = (CIndexer*)STUI->TU->CIdx; 2719 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing)) 2720 setThreadBackgroundPriority(); 2721 2722 bool hadError = static_cast<ASTUnit *>(STUI->TU->TUData)->Save(STUI->FileName); 2723 STUI->result = hadError ? CXSaveError_Unknown : CXSaveError_None; 2724} 2725 2726int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName, 2727 unsigned options) { 2728 if (!TU) 2729 return CXSaveError_InvalidTU; 2730 2731 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 2732 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 2733 if (!CXXUnit->hasSema()) 2734 return CXSaveError_InvalidTU; 2735 2736 SaveTranslationUnitInfo STUI = { TU, FileName, options, CXSaveError_None }; 2737 2738 if (!CXXUnit->getDiagnostics().hasUnrecoverableErrorOccurred() || 2739 getenv("LIBCLANG_NOTHREADS")) { 2740 clang_saveTranslationUnit_Impl(&STUI); 2741 2742 if (getenv("LIBCLANG_RESOURCE_USAGE")) 2743 PrintLibclangResourceUsage(TU); 2744 2745 return STUI.result; 2746 } 2747 2748 // We have an AST that has invalid nodes due to compiler errors. 2749 // Use a crash recovery thread for protection. 2750 2751 llvm::CrashRecoveryContext CRC; 2752 2753 if (!RunSafely(CRC, clang_saveTranslationUnit_Impl, &STUI)) { 2754 fprintf(stderr, "libclang: crash detected during AST saving: {\n"); 2755 fprintf(stderr, " 'filename' : '%s'\n", FileName); 2756 fprintf(stderr, " 'options' : %d,\n", options); 2757 fprintf(stderr, "}\n"); 2758 2759 return CXSaveError_Unknown; 2760 2761 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) { 2762 PrintLibclangResourceUsage(TU); 2763 } 2764 2765 return STUI.result; 2766} 2767 2768void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) { 2769 if (CTUnit) { 2770 // If the translation unit has been marked as unsafe to free, just discard 2771 // it. 2772 if (static_cast<ASTUnit *>(CTUnit->TUData)->isUnsafeToFree()) 2773 return; 2774 2775 delete static_cast<ASTUnit *>(CTUnit->TUData); 2776 disposeCXStringPool(CTUnit->StringPool); 2777 delete static_cast<CXDiagnosticSetImpl *>(CTUnit->Diagnostics); 2778 disposeOverridenCXCursorsPool(CTUnit->OverridenCursorsPool); 2779 delete CTUnit; 2780 } 2781} 2782 2783unsigned clang_defaultReparseOptions(CXTranslationUnit TU) { 2784 return CXReparse_None; 2785} 2786 2787struct ReparseTranslationUnitInfo { 2788 CXTranslationUnit TU; 2789 unsigned num_unsaved_files; 2790 struct CXUnsavedFile *unsaved_files; 2791 unsigned options; 2792 int result; 2793}; 2794 2795static void clang_reparseTranslationUnit_Impl(void *UserData) { 2796 ReparseTranslationUnitInfo *RTUI = 2797 static_cast<ReparseTranslationUnitInfo*>(UserData); 2798 CXTranslationUnit TU = RTUI->TU; 2799 2800 // Reset the associated diagnostics. 2801 delete static_cast<CXDiagnosticSetImpl*>(TU->Diagnostics); 2802 TU->Diagnostics = 0; 2803 2804 unsigned num_unsaved_files = RTUI->num_unsaved_files; 2805 struct CXUnsavedFile *unsaved_files = RTUI->unsaved_files; 2806 unsigned options = RTUI->options; 2807 (void) options; 2808 RTUI->result = 1; 2809 2810 if (!TU) 2811 return; 2812 2813 CIndexer *CXXIdx = (CIndexer*)TU->CIdx; 2814 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 2815 setThreadBackgroundPriority(); 2816 2817 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 2818 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 2819 2820 OwningPtr<std::vector<ASTUnit::RemappedFile> > 2821 RemappedFiles(new std::vector<ASTUnit::RemappedFile>()); 2822 2823 // Recover resources if we crash before exiting this function. 2824 llvm::CrashRecoveryContextCleanupRegistrar< 2825 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get()); 2826 2827 for (unsigned I = 0; I != num_unsaved_files; ++I) { 2828 StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length); 2829 const llvm::MemoryBuffer *Buffer 2830 = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename); 2831 RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename, 2832 Buffer)); 2833 } 2834 2835 if (!CXXUnit->Reparse(RemappedFiles->size() ? &(*RemappedFiles)[0] : 0, 2836 RemappedFiles->size())) 2837 RTUI->result = 0; 2838} 2839 2840int clang_reparseTranslationUnit(CXTranslationUnit TU, 2841 unsigned num_unsaved_files, 2842 struct CXUnsavedFile *unsaved_files, 2843 unsigned options) { 2844 ReparseTranslationUnitInfo RTUI = { TU, num_unsaved_files, unsaved_files, 2845 options, 0 }; 2846 2847 if (getenv("LIBCLANG_NOTHREADS")) { 2848 clang_reparseTranslationUnit_Impl(&RTUI); 2849 return RTUI.result; 2850 } 2851 2852 llvm::CrashRecoveryContext CRC; 2853 2854 if (!RunSafely(CRC, clang_reparseTranslationUnit_Impl, &RTUI)) { 2855 fprintf(stderr, "libclang: crash detected during reparsing\n"); 2856 static_cast<ASTUnit *>(TU->TUData)->setUnsafeToFree(true); 2857 return 1; 2858 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) 2859 PrintLibclangResourceUsage(TU); 2860 2861 return RTUI.result; 2862} 2863 2864 2865CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) { 2866 if (!CTUnit) 2867 return createCXString(""); 2868 2869 ASTUnit *CXXUnit = static_cast<ASTUnit *>(CTUnit->TUData); 2870 return createCXString(CXXUnit->getOriginalSourceFileName(), true); 2871} 2872 2873CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) { 2874 ASTUnit *CXXUnit = static_cast<ASTUnit*>(TU->TUData); 2875 return MakeCXCursor(CXXUnit->getASTContext().getTranslationUnitDecl(), TU); 2876} 2877 2878} // end: extern "C" 2879 2880//===----------------------------------------------------------------------===// 2881// CXFile Operations. 2882//===----------------------------------------------------------------------===// 2883 2884extern "C" { 2885CXString clang_getFileName(CXFile SFile) { 2886 if (!SFile) 2887 return createCXString((const char*)NULL); 2888 2889 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 2890 return createCXString(FEnt->getName()); 2891} 2892 2893time_t clang_getFileTime(CXFile SFile) { 2894 if (!SFile) 2895 return 0; 2896 2897 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 2898 return FEnt->getModificationTime(); 2899} 2900 2901CXFile clang_getFile(CXTranslationUnit tu, const char *file_name) { 2902 if (!tu) 2903 return 0; 2904 2905 ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData); 2906 2907 FileManager &FMgr = CXXUnit->getFileManager(); 2908 return const_cast<FileEntry *>(FMgr.getFile(file_name)); 2909} 2910 2911unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit tu, CXFile file) { 2912 if (!tu || !file) 2913 return 0; 2914 2915 ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData); 2916 FileEntry *FEnt = static_cast<FileEntry *>(file); 2917 return CXXUnit->getPreprocessor().getHeaderSearchInfo() 2918 .isFileMultipleIncludeGuarded(FEnt); 2919} 2920 2921} // end: extern "C" 2922 2923//===----------------------------------------------------------------------===// 2924// CXCursor Operations. 2925//===----------------------------------------------------------------------===// 2926 2927static Decl *getDeclFromExpr(Stmt *E) { 2928 if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 2929 return getDeclFromExpr(CE->getSubExpr()); 2930 2931 if (DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E)) 2932 return RefExpr->getDecl(); 2933 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) 2934 return ME->getMemberDecl(); 2935 if (ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E)) 2936 return RE->getDecl(); 2937 if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E)) { 2938 if (PRE->isExplicitProperty()) 2939 return PRE->getExplicitProperty(); 2940 // It could be messaging both getter and setter as in: 2941 // ++myobj.myprop; 2942 // in which case prefer to associate the setter since it is less obvious 2943 // from inspecting the source that the setter is going to get called. 2944 if (PRE->isMessagingSetter()) 2945 return PRE->getImplicitPropertySetter(); 2946 return PRE->getImplicitPropertyGetter(); 2947 } 2948 if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) 2949 return getDeclFromExpr(POE->getSyntacticForm()); 2950 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) 2951 if (Expr *Src = OVE->getSourceExpr()) 2952 return getDeclFromExpr(Src); 2953 2954 if (CallExpr *CE = dyn_cast<CallExpr>(E)) 2955 return getDeclFromExpr(CE->getCallee()); 2956 if (CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E)) 2957 if (!CE->isElidable()) 2958 return CE->getConstructor(); 2959 if (ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E)) 2960 return OME->getMethodDecl(); 2961 2962 if (ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E)) 2963 return PE->getProtocol(); 2964 if (SubstNonTypeTemplateParmPackExpr *NTTP 2965 = dyn_cast<SubstNonTypeTemplateParmPackExpr>(E)) 2966 return NTTP->getParameterPack(); 2967 if (SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 2968 if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) || 2969 isa<ParmVarDecl>(SizeOfPack->getPack())) 2970 return SizeOfPack->getPack(); 2971 2972 return 0; 2973} 2974 2975static SourceLocation getLocationFromExpr(Expr *E) { 2976 if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 2977 return getLocationFromExpr(CE->getSubExpr()); 2978 2979 if (ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E)) 2980 return /*FIXME:*/Msg->getLeftLoc(); 2981 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 2982 return DRE->getLocation(); 2983 if (MemberExpr *Member = dyn_cast<MemberExpr>(E)) 2984 return Member->getMemberLoc(); 2985 if (ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E)) 2986 return Ivar->getLocation(); 2987 if (SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 2988 return SizeOfPack->getPackLoc(); 2989 if (ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E)) 2990 return PropRef->getLocation(); 2991 2992 return E->getLocStart(); 2993} 2994 2995extern "C" { 2996 2997unsigned clang_visitChildren(CXCursor parent, 2998 CXCursorVisitor visitor, 2999 CXClientData client_data) { 3000 CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data, 3001 /*VisitPreprocessorLast=*/false); 3002 return CursorVis.VisitChildren(parent); 3003} 3004 3005#ifndef __has_feature 3006#define __has_feature(x) 0 3007#endif 3008#if __has_feature(blocks) 3009typedef enum CXChildVisitResult 3010 (^CXCursorVisitorBlock)(CXCursor cursor, CXCursor parent); 3011 3012static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 3013 CXClientData client_data) { 3014 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 3015 return block(cursor, parent); 3016} 3017#else 3018// If we are compiled with a compiler that doesn't have native blocks support, 3019// define and call the block manually, so the 3020typedef struct _CXChildVisitResult 3021{ 3022 void *isa; 3023 int flags; 3024 int reserved; 3025 enum CXChildVisitResult(*invoke)(struct _CXChildVisitResult*, CXCursor, 3026 CXCursor); 3027} *CXCursorVisitorBlock; 3028 3029static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 3030 CXClientData client_data) { 3031 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 3032 return block->invoke(block, cursor, parent); 3033} 3034#endif 3035 3036 3037unsigned clang_visitChildrenWithBlock(CXCursor parent, 3038 CXCursorVisitorBlock block) { 3039 return clang_visitChildren(parent, visitWithBlock, block); 3040} 3041 3042static CXString getDeclSpelling(Decl *D) { 3043 if (!D) 3044 return createCXString(""); 3045 3046 NamedDecl *ND = dyn_cast<NamedDecl>(D); 3047 if (!ND) { 3048 if (ObjCPropertyImplDecl *PropImpl =dyn_cast<ObjCPropertyImplDecl>(D)) 3049 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 3050 return createCXString(Property->getIdentifier()->getName()); 3051 3052 if (ImportDecl *ImportD = dyn_cast<ImportDecl>(D)) 3053 if (Module *Mod = ImportD->getImportedModule()) 3054 return createCXString(Mod->getFullModuleName()); 3055 3056 return createCXString(""); 3057 } 3058 3059 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND)) 3060 return createCXString(OMD->getSelector().getAsString()); 3061 3062 if (ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND)) 3063 // No, this isn't the same as the code below. getIdentifier() is non-virtual 3064 // and returns different names. NamedDecl returns the class name and 3065 // ObjCCategoryImplDecl returns the category name. 3066 return createCXString(CIMP->getIdentifier()->getNameStart()); 3067 3068 if (isa<UsingDirectiveDecl>(D)) 3069 return createCXString(""); 3070 3071 SmallString<1024> S; 3072 llvm::raw_svector_ostream os(S); 3073 ND->printName(os); 3074 3075 return createCXString(os.str()); 3076} 3077 3078CXString clang_getCursorSpelling(CXCursor C) { 3079 if (clang_isTranslationUnit(C.kind)) 3080 return clang_getTranslationUnitSpelling( 3081 static_cast<CXTranslationUnit>(C.data[2])); 3082 3083 if (clang_isReference(C.kind)) { 3084 switch (C.kind) { 3085 case CXCursor_ObjCSuperClassRef: { 3086 ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first; 3087 return createCXString(Super->getIdentifier()->getNameStart()); 3088 } 3089 case CXCursor_ObjCClassRef: { 3090 ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first; 3091 return createCXString(Class->getIdentifier()->getNameStart()); 3092 } 3093 case CXCursor_ObjCProtocolRef: { 3094 ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first; 3095 assert(OID && "getCursorSpelling(): Missing protocol decl"); 3096 return createCXString(OID->getIdentifier()->getNameStart()); 3097 } 3098 case CXCursor_CXXBaseSpecifier: { 3099 CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C); 3100 return createCXString(B->getType().getAsString()); 3101 } 3102 case CXCursor_TypeRef: { 3103 TypeDecl *Type = getCursorTypeRef(C).first; 3104 assert(Type && "Missing type decl"); 3105 3106 return createCXString(getCursorContext(C).getTypeDeclType(Type). 3107 getAsString()); 3108 } 3109 case CXCursor_TemplateRef: { 3110 TemplateDecl *Template = getCursorTemplateRef(C).first; 3111 assert(Template && "Missing template decl"); 3112 3113 return createCXString(Template->getNameAsString()); 3114 } 3115 3116 case CXCursor_NamespaceRef: { 3117 NamedDecl *NS = getCursorNamespaceRef(C).first; 3118 assert(NS && "Missing namespace decl"); 3119 3120 return createCXString(NS->getNameAsString()); 3121 } 3122 3123 case CXCursor_MemberRef: { 3124 FieldDecl *Field = getCursorMemberRef(C).first; 3125 assert(Field && "Missing member decl"); 3126 3127 return createCXString(Field->getNameAsString()); 3128 } 3129 3130 case CXCursor_LabelRef: { 3131 LabelStmt *Label = getCursorLabelRef(C).first; 3132 assert(Label && "Missing label"); 3133 3134 return createCXString(Label->getName()); 3135 } 3136 3137 case CXCursor_OverloadedDeclRef: { 3138 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 3139 if (Decl *D = Storage.dyn_cast<Decl *>()) { 3140 if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) 3141 return createCXString(ND->getNameAsString()); 3142 return createCXString(""); 3143 } 3144 if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>()) 3145 return createCXString(E->getName().getAsString()); 3146 OverloadedTemplateStorage *Ovl 3147 = Storage.get<OverloadedTemplateStorage*>(); 3148 if (Ovl->size() == 0) 3149 return createCXString(""); 3150 return createCXString((*Ovl->begin())->getNameAsString()); 3151 } 3152 3153 case CXCursor_VariableRef: { 3154 VarDecl *Var = getCursorVariableRef(C).first; 3155 assert(Var && "Missing variable decl"); 3156 3157 return createCXString(Var->getNameAsString()); 3158 } 3159 3160 default: 3161 return createCXString("<not implemented>"); 3162 } 3163 } 3164 3165 if (clang_isExpression(C.kind)) { 3166 Decl *D = getDeclFromExpr(getCursorExpr(C)); 3167 if (D) 3168 return getDeclSpelling(D); 3169 return createCXString(""); 3170 } 3171 3172 if (clang_isStatement(C.kind)) { 3173 Stmt *S = getCursorStmt(C); 3174 if (LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) 3175 return createCXString(Label->getName()); 3176 3177 return createCXString(""); 3178 } 3179 3180 if (C.kind == CXCursor_MacroExpansion) 3181 return createCXString(getCursorMacroExpansion(C)->getName() 3182 ->getNameStart()); 3183 3184 if (C.kind == CXCursor_MacroDefinition) 3185 return createCXString(getCursorMacroDefinition(C)->getName() 3186 ->getNameStart()); 3187 3188 if (C.kind == CXCursor_InclusionDirective) 3189 return createCXString(getCursorInclusionDirective(C)->getFileName()); 3190 3191 if (clang_isDeclaration(C.kind)) 3192 return getDeclSpelling(getCursorDecl(C)); 3193 3194 if (C.kind == CXCursor_AnnotateAttr) { 3195 AnnotateAttr *AA = cast<AnnotateAttr>(cxcursor::getCursorAttr(C)); 3196 return createCXString(AA->getAnnotation()); 3197 } 3198 3199 if (C.kind == CXCursor_AsmLabelAttr) { 3200 AsmLabelAttr *AA = cast<AsmLabelAttr>(cxcursor::getCursorAttr(C)); 3201 return createCXString(AA->getLabel()); 3202 } 3203 3204 return createCXString(""); 3205} 3206 3207CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C, 3208 unsigned pieceIndex, 3209 unsigned options) { 3210 if (clang_Cursor_isNull(C)) 3211 return clang_getNullRange(); 3212 3213 ASTContext &Ctx = getCursorContext(C); 3214 3215 if (clang_isStatement(C.kind)) { 3216 Stmt *S = getCursorStmt(C); 3217 if (LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) { 3218 if (pieceIndex > 0) 3219 return clang_getNullRange(); 3220 return cxloc::translateSourceRange(Ctx, Label->getIdentLoc()); 3221 } 3222 3223 return clang_getNullRange(); 3224 } 3225 3226 if (C.kind == CXCursor_ObjCMessageExpr) { 3227 if (ObjCMessageExpr * 3228 ME = dyn_cast_or_null<ObjCMessageExpr>(getCursorExpr(C))) { 3229 if (pieceIndex >= ME->getNumSelectorLocs()) 3230 return clang_getNullRange(); 3231 return cxloc::translateSourceRange(Ctx, ME->getSelectorLoc(pieceIndex)); 3232 } 3233 } 3234 3235 if (C.kind == CXCursor_ObjCInstanceMethodDecl || 3236 C.kind == CXCursor_ObjCClassMethodDecl) { 3237 if (ObjCMethodDecl * 3238 MD = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(C))) { 3239 if (pieceIndex >= MD->getNumSelectorLocs()) 3240 return clang_getNullRange(); 3241 return cxloc::translateSourceRange(Ctx, MD->getSelectorLoc(pieceIndex)); 3242 } 3243 } 3244 3245 if (C.kind == CXCursor_ObjCCategoryDecl || 3246 C.kind == CXCursor_ObjCCategoryImplDecl) { 3247 if (pieceIndex > 0) 3248 return clang_getNullRange(); 3249 if (ObjCCategoryDecl * 3250 CD = dyn_cast_or_null<ObjCCategoryDecl>(getCursorDecl(C))) 3251 return cxloc::translateSourceRange(Ctx, CD->getCategoryNameLoc()); 3252 if (ObjCCategoryImplDecl * 3253 CID = dyn_cast_or_null<ObjCCategoryImplDecl>(getCursorDecl(C))) 3254 return cxloc::translateSourceRange(Ctx, CID->getCategoryNameLoc()); 3255 } 3256 3257 if (C.kind == CXCursor_ModuleImportDecl) { 3258 if (pieceIndex > 0) 3259 return clang_getNullRange(); 3260 if (ImportDecl *ImportD = dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) { 3261 ArrayRef<SourceLocation> Locs = ImportD->getIdentifierLocs(); 3262 if (!Locs.empty()) 3263 return cxloc::translateSourceRange(Ctx, 3264 SourceRange(Locs.front(), Locs.back())); 3265 } 3266 return clang_getNullRange(); 3267 } 3268 3269 // FIXME: A CXCursor_InclusionDirective should give the location of the 3270 // filename, but we don't keep track of this. 3271 3272 // FIXME: A CXCursor_AnnotateAttr should give the location of the annotation 3273 // but we don't keep track of this. 3274 3275 // FIXME: A CXCursor_AsmLabelAttr should give the location of the label 3276 // but we don't keep track of this. 3277 3278 // Default handling, give the location of the cursor. 3279 3280 if (pieceIndex > 0) 3281 return clang_getNullRange(); 3282 3283 CXSourceLocation CXLoc = clang_getCursorLocation(C); 3284 SourceLocation Loc = cxloc::translateSourceLocation(CXLoc); 3285 return cxloc::translateSourceRange(Ctx, Loc); 3286} 3287 3288CXString clang_getCursorDisplayName(CXCursor C) { 3289 if (!clang_isDeclaration(C.kind)) 3290 return clang_getCursorSpelling(C); 3291 3292 Decl *D = getCursorDecl(C); 3293 if (!D) 3294 return createCXString(""); 3295 3296 PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy(); 3297 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 3298 D = FunTmpl->getTemplatedDecl(); 3299 3300 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 3301 SmallString<64> Str; 3302 llvm::raw_svector_ostream OS(Str); 3303 OS << *Function; 3304 if (Function->getPrimaryTemplate()) 3305 OS << "<>"; 3306 OS << "("; 3307 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) { 3308 if (I) 3309 OS << ", "; 3310 OS << Function->getParamDecl(I)->getType().getAsString(Policy); 3311 } 3312 3313 if (Function->isVariadic()) { 3314 if (Function->getNumParams()) 3315 OS << ", "; 3316 OS << "..."; 3317 } 3318 OS << ")"; 3319 return createCXString(OS.str()); 3320 } 3321 3322 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) { 3323 SmallString<64> Str; 3324 llvm::raw_svector_ostream OS(Str); 3325 OS << *ClassTemplate; 3326 OS << "<"; 3327 TemplateParameterList *Params = ClassTemplate->getTemplateParameters(); 3328 for (unsigned I = 0, N = Params->size(); I != N; ++I) { 3329 if (I) 3330 OS << ", "; 3331 3332 NamedDecl *Param = Params->getParam(I); 3333 if (Param->getIdentifier()) { 3334 OS << Param->getIdentifier()->getName(); 3335 continue; 3336 } 3337 3338 // There is no parameter name, which makes this tricky. Try to come up 3339 // with something useful that isn't too long. 3340 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 3341 OS << (TTP->wasDeclaredWithTypename()? "typename" : "class"); 3342 else if (NonTypeTemplateParmDecl *NTTP 3343 = dyn_cast<NonTypeTemplateParmDecl>(Param)) 3344 OS << NTTP->getType().getAsString(Policy); 3345 else 3346 OS << "template<...> class"; 3347 } 3348 3349 OS << ">"; 3350 return createCXString(OS.str()); 3351 } 3352 3353 if (ClassTemplateSpecializationDecl *ClassSpec 3354 = dyn_cast<ClassTemplateSpecializationDecl>(D)) { 3355 // If the type was explicitly written, use that. 3356 if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten()) 3357 return createCXString(TSInfo->getType().getAsString(Policy)); 3358 3359 SmallString<64> Str; 3360 llvm::raw_svector_ostream OS(Str); 3361 OS << *ClassSpec; 3362 OS << TemplateSpecializationType::PrintTemplateArgumentList( 3363 ClassSpec->getTemplateArgs().data(), 3364 ClassSpec->getTemplateArgs().size(), 3365 Policy); 3366 return createCXString(OS.str()); 3367 } 3368 3369 return clang_getCursorSpelling(C); 3370} 3371 3372CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) { 3373 switch (Kind) { 3374 case CXCursor_FunctionDecl: 3375 return createCXString("FunctionDecl"); 3376 case CXCursor_TypedefDecl: 3377 return createCXString("TypedefDecl"); 3378 case CXCursor_EnumDecl: 3379 return createCXString("EnumDecl"); 3380 case CXCursor_EnumConstantDecl: 3381 return createCXString("EnumConstantDecl"); 3382 case CXCursor_StructDecl: 3383 return createCXString("StructDecl"); 3384 case CXCursor_UnionDecl: 3385 return createCXString("UnionDecl"); 3386 case CXCursor_ClassDecl: 3387 return createCXString("ClassDecl"); 3388 case CXCursor_FieldDecl: 3389 return createCXString("FieldDecl"); 3390 case CXCursor_VarDecl: 3391 return createCXString("VarDecl"); 3392 case CXCursor_ParmDecl: 3393 return createCXString("ParmDecl"); 3394 case CXCursor_ObjCInterfaceDecl: 3395 return createCXString("ObjCInterfaceDecl"); 3396 case CXCursor_ObjCCategoryDecl: 3397 return createCXString("ObjCCategoryDecl"); 3398 case CXCursor_ObjCProtocolDecl: 3399 return createCXString("ObjCProtocolDecl"); 3400 case CXCursor_ObjCPropertyDecl: 3401 return createCXString("ObjCPropertyDecl"); 3402 case CXCursor_ObjCIvarDecl: 3403 return createCXString("ObjCIvarDecl"); 3404 case CXCursor_ObjCInstanceMethodDecl: 3405 return createCXString("ObjCInstanceMethodDecl"); 3406 case CXCursor_ObjCClassMethodDecl: 3407 return createCXString("ObjCClassMethodDecl"); 3408 case CXCursor_ObjCImplementationDecl: 3409 return createCXString("ObjCImplementationDecl"); 3410 case CXCursor_ObjCCategoryImplDecl: 3411 return createCXString("ObjCCategoryImplDecl"); 3412 case CXCursor_CXXMethod: 3413 return createCXString("CXXMethod"); 3414 case CXCursor_UnexposedDecl: 3415 return createCXString("UnexposedDecl"); 3416 case CXCursor_ObjCSuperClassRef: 3417 return createCXString("ObjCSuperClassRef"); 3418 case CXCursor_ObjCProtocolRef: 3419 return createCXString("ObjCProtocolRef"); 3420 case CXCursor_ObjCClassRef: 3421 return createCXString("ObjCClassRef"); 3422 case CXCursor_TypeRef: 3423 return createCXString("TypeRef"); 3424 case CXCursor_TemplateRef: 3425 return createCXString("TemplateRef"); 3426 case CXCursor_NamespaceRef: 3427 return createCXString("NamespaceRef"); 3428 case CXCursor_MemberRef: 3429 return createCXString("MemberRef"); 3430 case CXCursor_LabelRef: 3431 return createCXString("LabelRef"); 3432 case CXCursor_OverloadedDeclRef: 3433 return createCXString("OverloadedDeclRef"); 3434 case CXCursor_VariableRef: 3435 return createCXString("VariableRef"); 3436 case CXCursor_IntegerLiteral: 3437 return createCXString("IntegerLiteral"); 3438 case CXCursor_FloatingLiteral: 3439 return createCXString("FloatingLiteral"); 3440 case CXCursor_ImaginaryLiteral: 3441 return createCXString("ImaginaryLiteral"); 3442 case CXCursor_StringLiteral: 3443 return createCXString("StringLiteral"); 3444 case CXCursor_CharacterLiteral: 3445 return createCXString("CharacterLiteral"); 3446 case CXCursor_ParenExpr: 3447 return createCXString("ParenExpr"); 3448 case CXCursor_UnaryOperator: 3449 return createCXString("UnaryOperator"); 3450 case CXCursor_ArraySubscriptExpr: 3451 return createCXString("ArraySubscriptExpr"); 3452 case CXCursor_BinaryOperator: 3453 return createCXString("BinaryOperator"); 3454 case CXCursor_CompoundAssignOperator: 3455 return createCXString("CompoundAssignOperator"); 3456 case CXCursor_ConditionalOperator: 3457 return createCXString("ConditionalOperator"); 3458 case CXCursor_CStyleCastExpr: 3459 return createCXString("CStyleCastExpr"); 3460 case CXCursor_CompoundLiteralExpr: 3461 return createCXString("CompoundLiteralExpr"); 3462 case CXCursor_InitListExpr: 3463 return createCXString("InitListExpr"); 3464 case CXCursor_AddrLabelExpr: 3465 return createCXString("AddrLabelExpr"); 3466 case CXCursor_StmtExpr: 3467 return createCXString("StmtExpr"); 3468 case CXCursor_GenericSelectionExpr: 3469 return createCXString("GenericSelectionExpr"); 3470 case CXCursor_GNUNullExpr: 3471 return createCXString("GNUNullExpr"); 3472 case CXCursor_CXXStaticCastExpr: 3473 return createCXString("CXXStaticCastExpr"); 3474 case CXCursor_CXXDynamicCastExpr: 3475 return createCXString("CXXDynamicCastExpr"); 3476 case CXCursor_CXXReinterpretCastExpr: 3477 return createCXString("CXXReinterpretCastExpr"); 3478 case CXCursor_CXXConstCastExpr: 3479 return createCXString("CXXConstCastExpr"); 3480 case CXCursor_CXXFunctionalCastExpr: 3481 return createCXString("CXXFunctionalCastExpr"); 3482 case CXCursor_CXXTypeidExpr: 3483 return createCXString("CXXTypeidExpr"); 3484 case CXCursor_CXXBoolLiteralExpr: 3485 return createCXString("CXXBoolLiteralExpr"); 3486 case CXCursor_CXXNullPtrLiteralExpr: 3487 return createCXString("CXXNullPtrLiteralExpr"); 3488 case CXCursor_CXXThisExpr: 3489 return createCXString("CXXThisExpr"); 3490 case CXCursor_CXXThrowExpr: 3491 return createCXString("CXXThrowExpr"); 3492 case CXCursor_CXXNewExpr: 3493 return createCXString("CXXNewExpr"); 3494 case CXCursor_CXXDeleteExpr: 3495 return createCXString("CXXDeleteExpr"); 3496 case CXCursor_UnaryExpr: 3497 return createCXString("UnaryExpr"); 3498 case CXCursor_ObjCStringLiteral: 3499 return createCXString("ObjCStringLiteral"); 3500 case CXCursor_ObjCBoolLiteralExpr: 3501 return createCXString("ObjCBoolLiteralExpr"); 3502 case CXCursor_ObjCEncodeExpr: 3503 return createCXString("ObjCEncodeExpr"); 3504 case CXCursor_ObjCSelectorExpr: 3505 return createCXString("ObjCSelectorExpr"); 3506 case CXCursor_ObjCProtocolExpr: 3507 return createCXString("ObjCProtocolExpr"); 3508 case CXCursor_ObjCBridgedCastExpr: 3509 return createCXString("ObjCBridgedCastExpr"); 3510 case CXCursor_BlockExpr: 3511 return createCXString("BlockExpr"); 3512 case CXCursor_PackExpansionExpr: 3513 return createCXString("PackExpansionExpr"); 3514 case CXCursor_SizeOfPackExpr: 3515 return createCXString("SizeOfPackExpr"); 3516 case CXCursor_LambdaExpr: 3517 return createCXString("LambdaExpr"); 3518 case CXCursor_UnexposedExpr: 3519 return createCXString("UnexposedExpr"); 3520 case CXCursor_DeclRefExpr: 3521 return createCXString("DeclRefExpr"); 3522 case CXCursor_MemberRefExpr: 3523 return createCXString("MemberRefExpr"); 3524 case CXCursor_CallExpr: 3525 return createCXString("CallExpr"); 3526 case CXCursor_ObjCMessageExpr: 3527 return createCXString("ObjCMessageExpr"); 3528 case CXCursor_UnexposedStmt: 3529 return createCXString("UnexposedStmt"); 3530 case CXCursor_DeclStmt: 3531 return createCXString("DeclStmt"); 3532 case CXCursor_LabelStmt: 3533 return createCXString("LabelStmt"); 3534 case CXCursor_CompoundStmt: 3535 return createCXString("CompoundStmt"); 3536 case CXCursor_CaseStmt: 3537 return createCXString("CaseStmt"); 3538 case CXCursor_DefaultStmt: 3539 return createCXString("DefaultStmt"); 3540 case CXCursor_IfStmt: 3541 return createCXString("IfStmt"); 3542 case CXCursor_SwitchStmt: 3543 return createCXString("SwitchStmt"); 3544 case CXCursor_WhileStmt: 3545 return createCXString("WhileStmt"); 3546 case CXCursor_DoStmt: 3547 return createCXString("DoStmt"); 3548 case CXCursor_ForStmt: 3549 return createCXString("ForStmt"); 3550 case CXCursor_GotoStmt: 3551 return createCXString("GotoStmt"); 3552 case CXCursor_IndirectGotoStmt: 3553 return createCXString("IndirectGotoStmt"); 3554 case CXCursor_ContinueStmt: 3555 return createCXString("ContinueStmt"); 3556 case CXCursor_BreakStmt: 3557 return createCXString("BreakStmt"); 3558 case CXCursor_ReturnStmt: 3559 return createCXString("ReturnStmt"); 3560 case CXCursor_GCCAsmStmt: 3561 return createCXString("GCCAsmStmt"); 3562 case CXCursor_MSAsmStmt: 3563 return createCXString("MSAsmStmt"); 3564 case CXCursor_ObjCAtTryStmt: 3565 return createCXString("ObjCAtTryStmt"); 3566 case CXCursor_ObjCAtCatchStmt: 3567 return createCXString("ObjCAtCatchStmt"); 3568 case CXCursor_ObjCAtFinallyStmt: 3569 return createCXString("ObjCAtFinallyStmt"); 3570 case CXCursor_ObjCAtThrowStmt: 3571 return createCXString("ObjCAtThrowStmt"); 3572 case CXCursor_ObjCAtSynchronizedStmt: 3573 return createCXString("ObjCAtSynchronizedStmt"); 3574 case CXCursor_ObjCAutoreleasePoolStmt: 3575 return createCXString("ObjCAutoreleasePoolStmt"); 3576 case CXCursor_ObjCForCollectionStmt: 3577 return createCXString("ObjCForCollectionStmt"); 3578 case CXCursor_CXXCatchStmt: 3579 return createCXString("CXXCatchStmt"); 3580 case CXCursor_CXXTryStmt: 3581 return createCXString("CXXTryStmt"); 3582 case CXCursor_CXXForRangeStmt: 3583 return createCXString("CXXForRangeStmt"); 3584 case CXCursor_SEHTryStmt: 3585 return createCXString("SEHTryStmt"); 3586 case CXCursor_SEHExceptStmt: 3587 return createCXString("SEHExceptStmt"); 3588 case CXCursor_SEHFinallyStmt: 3589 return createCXString("SEHFinallyStmt"); 3590 case CXCursor_NullStmt: 3591 return createCXString("NullStmt"); 3592 case CXCursor_InvalidFile: 3593 return createCXString("InvalidFile"); 3594 case CXCursor_InvalidCode: 3595 return createCXString("InvalidCode"); 3596 case CXCursor_NoDeclFound: 3597 return createCXString("NoDeclFound"); 3598 case CXCursor_NotImplemented: 3599 return createCXString("NotImplemented"); 3600 case CXCursor_TranslationUnit: 3601 return createCXString("TranslationUnit"); 3602 case CXCursor_UnexposedAttr: 3603 return createCXString("UnexposedAttr"); 3604 case CXCursor_IBActionAttr: 3605 return createCXString("attribute(ibaction)"); 3606 case CXCursor_IBOutletAttr: 3607 return createCXString("attribute(iboutlet)"); 3608 case CXCursor_IBOutletCollectionAttr: 3609 return createCXString("attribute(iboutletcollection)"); 3610 case CXCursor_CXXFinalAttr: 3611 return createCXString("attribute(final)"); 3612 case CXCursor_CXXOverrideAttr: 3613 return createCXString("attribute(override)"); 3614 case CXCursor_AnnotateAttr: 3615 return createCXString("attribute(annotate)"); 3616 case CXCursor_AsmLabelAttr: 3617 return createCXString("asm label"); 3618 case CXCursor_PreprocessingDirective: 3619 return createCXString("preprocessing directive"); 3620 case CXCursor_MacroDefinition: 3621 return createCXString("macro definition"); 3622 case CXCursor_MacroExpansion: 3623 return createCXString("macro expansion"); 3624 case CXCursor_InclusionDirective: 3625 return createCXString("inclusion directive"); 3626 case CXCursor_Namespace: 3627 return createCXString("Namespace"); 3628 case CXCursor_LinkageSpec: 3629 return createCXString("LinkageSpec"); 3630 case CXCursor_CXXBaseSpecifier: 3631 return createCXString("C++ base class specifier"); 3632 case CXCursor_Constructor: 3633 return createCXString("CXXConstructor"); 3634 case CXCursor_Destructor: 3635 return createCXString("CXXDestructor"); 3636 case CXCursor_ConversionFunction: 3637 return createCXString("CXXConversion"); 3638 case CXCursor_TemplateTypeParameter: 3639 return createCXString("TemplateTypeParameter"); 3640 case CXCursor_NonTypeTemplateParameter: 3641 return createCXString("NonTypeTemplateParameter"); 3642 case CXCursor_TemplateTemplateParameter: 3643 return createCXString("TemplateTemplateParameter"); 3644 case CXCursor_FunctionTemplate: 3645 return createCXString("FunctionTemplate"); 3646 case CXCursor_ClassTemplate: 3647 return createCXString("ClassTemplate"); 3648 case CXCursor_ClassTemplatePartialSpecialization: 3649 return createCXString("ClassTemplatePartialSpecialization"); 3650 case CXCursor_NamespaceAlias: 3651 return createCXString("NamespaceAlias"); 3652 case CXCursor_UsingDirective: 3653 return createCXString("UsingDirective"); 3654 case CXCursor_UsingDeclaration: 3655 return createCXString("UsingDeclaration"); 3656 case CXCursor_TypeAliasDecl: 3657 return createCXString("TypeAliasDecl"); 3658 case CXCursor_ObjCSynthesizeDecl: 3659 return createCXString("ObjCSynthesizeDecl"); 3660 case CXCursor_ObjCDynamicDecl: 3661 return createCXString("ObjCDynamicDecl"); 3662 case CXCursor_CXXAccessSpecifier: 3663 return createCXString("CXXAccessSpecifier"); 3664 case CXCursor_ModuleImportDecl: 3665 return createCXString("ModuleImport"); 3666 } 3667 3668 llvm_unreachable("Unhandled CXCursorKind"); 3669} 3670 3671struct GetCursorData { 3672 SourceLocation TokenBeginLoc; 3673 bool PointsAtMacroArgExpansion; 3674 bool VisitedObjCPropertyImplDecl; 3675 SourceLocation VisitedDeclaratorDeclStartLoc; 3676 CXCursor &BestCursor; 3677 3678 GetCursorData(SourceManager &SM, 3679 SourceLocation tokenBegin, CXCursor &outputCursor) 3680 : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) { 3681 PointsAtMacroArgExpansion = SM.isMacroArgExpansion(tokenBegin); 3682 VisitedObjCPropertyImplDecl = false; 3683 } 3684}; 3685 3686static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor, 3687 CXCursor parent, 3688 CXClientData client_data) { 3689 GetCursorData *Data = static_cast<GetCursorData *>(client_data); 3690 CXCursor *BestCursor = &Data->BestCursor; 3691 3692 // If we point inside a macro argument we should provide info of what the 3693 // token is so use the actual cursor, don't replace it with a macro expansion 3694 // cursor. 3695 if (cursor.kind == CXCursor_MacroExpansion && Data->PointsAtMacroArgExpansion) 3696 return CXChildVisit_Recurse; 3697 3698 if (clang_isDeclaration(cursor.kind)) { 3699 // Avoid having the implicit methods override the property decls. 3700 if (ObjCMethodDecl *MD 3701 = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) { 3702 if (MD->isImplicit()) 3703 return CXChildVisit_Break; 3704 3705 } else if (ObjCInterfaceDecl *ID 3706 = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(cursor))) { 3707 // Check that when we have multiple @class references in the same line, 3708 // that later ones do not override the previous ones. 3709 // If we have: 3710 // @class Foo, Bar; 3711 // source ranges for both start at '@', so 'Bar' will end up overriding 3712 // 'Foo' even though the cursor location was at 'Foo'. 3713 if (BestCursor->kind == CXCursor_ObjCInterfaceDecl || 3714 BestCursor->kind == CXCursor_ObjCClassRef) 3715 if (ObjCInterfaceDecl *PrevID 3716 = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(*BestCursor))){ 3717 if (PrevID != ID && 3718 !PrevID->isThisDeclarationADefinition() && 3719 !ID->isThisDeclarationADefinition()) 3720 return CXChildVisit_Break; 3721 } 3722 3723 } else if (DeclaratorDecl *DD 3724 = dyn_cast_or_null<DeclaratorDecl>(getCursorDecl(cursor))) { 3725 SourceLocation StartLoc = DD->getSourceRange().getBegin(); 3726 // Check that when we have multiple declarators in the same line, 3727 // that later ones do not override the previous ones. 3728 // If we have: 3729 // int Foo, Bar; 3730 // source ranges for both start at 'int', so 'Bar' will end up overriding 3731 // 'Foo' even though the cursor location was at 'Foo'. 3732 if (Data->VisitedDeclaratorDeclStartLoc == StartLoc) 3733 return CXChildVisit_Break; 3734 Data->VisitedDeclaratorDeclStartLoc = StartLoc; 3735 3736 } else if (ObjCPropertyImplDecl *PropImp 3737 = dyn_cast_or_null<ObjCPropertyImplDecl>(getCursorDecl(cursor))) { 3738 (void)PropImp; 3739 // Check that when we have multiple @synthesize in the same line, 3740 // that later ones do not override the previous ones. 3741 // If we have: 3742 // @synthesize Foo, Bar; 3743 // source ranges for both start at '@', so 'Bar' will end up overriding 3744 // 'Foo' even though the cursor location was at 'Foo'. 3745 if (Data->VisitedObjCPropertyImplDecl) 3746 return CXChildVisit_Break; 3747 Data->VisitedObjCPropertyImplDecl = true; 3748 } 3749 } 3750 3751 if (clang_isExpression(cursor.kind) && 3752 clang_isDeclaration(BestCursor->kind)) { 3753 if (Decl *D = getCursorDecl(*BestCursor)) { 3754 // Avoid having the cursor of an expression replace the declaration cursor 3755 // when the expression source range overlaps the declaration range. 3756 // This can happen for C++ constructor expressions whose range generally 3757 // include the variable declaration, e.g.: 3758 // MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl cursor. 3759 if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() && 3760 D->getLocation() == Data->TokenBeginLoc) 3761 return CXChildVisit_Break; 3762 } 3763 } 3764 3765 // If our current best cursor is the construction of a temporary object, 3766 // don't replace that cursor with a type reference, because we want 3767 // clang_getCursor() to point at the constructor. 3768 if (clang_isExpression(BestCursor->kind) && 3769 isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) && 3770 cursor.kind == CXCursor_TypeRef) { 3771 // Keep the cursor pointing at CXXTemporaryObjectExpr but also mark it 3772 // as having the actual point on the type reference. 3773 *BestCursor = getTypeRefedCallExprCursor(*BestCursor); 3774 return CXChildVisit_Recurse; 3775 } 3776 3777 *BestCursor = cursor; 3778 return CXChildVisit_Recurse; 3779} 3780 3781CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) { 3782 if (!TU) 3783 return clang_getNullCursor(); 3784 3785 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 3786 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 3787 3788 SourceLocation SLoc = cxloc::translateSourceLocation(Loc); 3789 CXCursor Result = cxcursor::getCursor(TU, SLoc); 3790 3791 bool Logging = getenv("LIBCLANG_LOGGING"); 3792 if (Logging) { 3793 CXFile SearchFile; 3794 unsigned SearchLine, SearchColumn; 3795 CXFile ResultFile; 3796 unsigned ResultLine, ResultColumn; 3797 CXString SearchFileName, ResultFileName, KindSpelling, USR; 3798 const char *IsDef = clang_isCursorDefinition(Result)? " (Definition)" : ""; 3799 CXSourceLocation ResultLoc = clang_getCursorLocation(Result); 3800 3801 clang_getExpansionLocation(Loc, &SearchFile, &SearchLine, &SearchColumn, 0); 3802 clang_getExpansionLocation(ResultLoc, &ResultFile, &ResultLine, 3803 &ResultColumn, 0); 3804 SearchFileName = clang_getFileName(SearchFile); 3805 ResultFileName = clang_getFileName(ResultFile); 3806 KindSpelling = clang_getCursorKindSpelling(Result.kind); 3807 USR = clang_getCursorUSR(Result); 3808 fprintf(stderr, "clang_getCursor(%s:%d:%d) = %s(%s:%d:%d):%s%s\n", 3809 clang_getCString(SearchFileName), SearchLine, SearchColumn, 3810 clang_getCString(KindSpelling), 3811 clang_getCString(ResultFileName), ResultLine, ResultColumn, 3812 clang_getCString(USR), IsDef); 3813 clang_disposeString(SearchFileName); 3814 clang_disposeString(ResultFileName); 3815 clang_disposeString(KindSpelling); 3816 clang_disposeString(USR); 3817 3818 CXCursor Definition = clang_getCursorDefinition(Result); 3819 if (!clang_equalCursors(Definition, clang_getNullCursor())) { 3820 CXSourceLocation DefinitionLoc = clang_getCursorLocation(Definition); 3821 CXString DefinitionKindSpelling 3822 = clang_getCursorKindSpelling(Definition.kind); 3823 CXFile DefinitionFile; 3824 unsigned DefinitionLine, DefinitionColumn; 3825 clang_getExpansionLocation(DefinitionLoc, &DefinitionFile, 3826 &DefinitionLine, &DefinitionColumn, 0); 3827 CXString DefinitionFileName = clang_getFileName(DefinitionFile); 3828 fprintf(stderr, " -> %s(%s:%d:%d)\n", 3829 clang_getCString(DefinitionKindSpelling), 3830 clang_getCString(DefinitionFileName), 3831 DefinitionLine, DefinitionColumn); 3832 clang_disposeString(DefinitionFileName); 3833 clang_disposeString(DefinitionKindSpelling); 3834 } 3835 } 3836 3837 return Result; 3838} 3839 3840CXCursor clang_getNullCursor(void) { 3841 return MakeCXCursorInvalid(CXCursor_InvalidFile); 3842} 3843 3844unsigned clang_equalCursors(CXCursor X, CXCursor Y) { 3845 return X == Y; 3846} 3847 3848unsigned clang_hashCursor(CXCursor C) { 3849 unsigned Index = 0; 3850 if (clang_isExpression(C.kind) || clang_isStatement(C.kind)) 3851 Index = 1; 3852 3853 return llvm::DenseMapInfo<std::pair<unsigned, void*> >::getHashValue( 3854 std::make_pair(C.kind, C.data[Index])); 3855} 3856 3857unsigned clang_isInvalid(enum CXCursorKind K) { 3858 return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid; 3859} 3860 3861unsigned clang_isDeclaration(enum CXCursorKind K) { 3862 return (K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl) || 3863 (K >= CXCursor_FirstExtraDecl && K <= CXCursor_LastExtraDecl); 3864} 3865 3866unsigned clang_isReference(enum CXCursorKind K) { 3867 return K >= CXCursor_FirstRef && K <= CXCursor_LastRef; 3868} 3869 3870unsigned clang_isExpression(enum CXCursorKind K) { 3871 return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr; 3872} 3873 3874unsigned clang_isStatement(enum CXCursorKind K) { 3875 return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt; 3876} 3877 3878unsigned clang_isAttribute(enum CXCursorKind K) { 3879 return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr; 3880} 3881 3882unsigned clang_isTranslationUnit(enum CXCursorKind K) { 3883 return K == CXCursor_TranslationUnit; 3884} 3885 3886unsigned clang_isPreprocessing(enum CXCursorKind K) { 3887 return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing; 3888} 3889 3890unsigned clang_isUnexposed(enum CXCursorKind K) { 3891 switch (K) { 3892 case CXCursor_UnexposedDecl: 3893 case CXCursor_UnexposedExpr: 3894 case CXCursor_UnexposedStmt: 3895 case CXCursor_UnexposedAttr: 3896 return true; 3897 default: 3898 return false; 3899 } 3900} 3901 3902CXCursorKind clang_getCursorKind(CXCursor C) { 3903 return C.kind; 3904} 3905 3906CXSourceLocation clang_getCursorLocation(CXCursor C) { 3907 if (clang_isReference(C.kind)) { 3908 switch (C.kind) { 3909 case CXCursor_ObjCSuperClassRef: { 3910 std::pair<ObjCInterfaceDecl *, SourceLocation> P 3911 = getCursorObjCSuperClassRef(C); 3912 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3913 } 3914 3915 case CXCursor_ObjCProtocolRef: { 3916 std::pair<ObjCProtocolDecl *, SourceLocation> P 3917 = getCursorObjCProtocolRef(C); 3918 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3919 } 3920 3921 case CXCursor_ObjCClassRef: { 3922 std::pair<ObjCInterfaceDecl *, SourceLocation> P 3923 = getCursorObjCClassRef(C); 3924 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3925 } 3926 3927 case CXCursor_TypeRef: { 3928 std::pair<TypeDecl *, SourceLocation> P = getCursorTypeRef(C); 3929 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3930 } 3931 3932 case CXCursor_TemplateRef: { 3933 std::pair<TemplateDecl *, SourceLocation> P = getCursorTemplateRef(C); 3934 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3935 } 3936 3937 case CXCursor_NamespaceRef: { 3938 std::pair<NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C); 3939 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3940 } 3941 3942 case CXCursor_MemberRef: { 3943 std::pair<FieldDecl *, SourceLocation> P = getCursorMemberRef(C); 3944 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3945 } 3946 3947 case CXCursor_VariableRef: { 3948 std::pair<VarDecl *, SourceLocation> P = getCursorVariableRef(C); 3949 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3950 } 3951 3952 case CXCursor_CXXBaseSpecifier: { 3953 CXXBaseSpecifier *BaseSpec = getCursorCXXBaseSpecifier(C); 3954 if (!BaseSpec) 3955 return clang_getNullLocation(); 3956 3957 if (TypeSourceInfo *TSInfo = BaseSpec->getTypeSourceInfo()) 3958 return cxloc::translateSourceLocation(getCursorContext(C), 3959 TSInfo->getTypeLoc().getBeginLoc()); 3960 3961 return cxloc::translateSourceLocation(getCursorContext(C), 3962 BaseSpec->getLocStart()); 3963 } 3964 3965 case CXCursor_LabelRef: { 3966 std::pair<LabelStmt *, SourceLocation> P = getCursorLabelRef(C); 3967 return cxloc::translateSourceLocation(getCursorContext(C), P.second); 3968 } 3969 3970 case CXCursor_OverloadedDeclRef: 3971 return cxloc::translateSourceLocation(getCursorContext(C), 3972 getCursorOverloadedDeclRef(C).second); 3973 3974 default: 3975 // FIXME: Need a way to enumerate all non-reference cases. 3976 llvm_unreachable("Missed a reference kind"); 3977 } 3978 } 3979 3980 if (clang_isExpression(C.kind)) 3981 return cxloc::translateSourceLocation(getCursorContext(C), 3982 getLocationFromExpr(getCursorExpr(C))); 3983 3984 if (clang_isStatement(C.kind)) 3985 return cxloc::translateSourceLocation(getCursorContext(C), 3986 getCursorStmt(C)->getLocStart()); 3987 3988 if (C.kind == CXCursor_PreprocessingDirective) { 3989 SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin(); 3990 return cxloc::translateSourceLocation(getCursorContext(C), L); 3991 } 3992 3993 if (C.kind == CXCursor_MacroExpansion) { 3994 SourceLocation L 3995 = cxcursor::getCursorMacroExpansion(C)->getSourceRange().getBegin(); 3996 return cxloc::translateSourceLocation(getCursorContext(C), L); 3997 } 3998 3999 if (C.kind == CXCursor_MacroDefinition) { 4000 SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation(); 4001 return cxloc::translateSourceLocation(getCursorContext(C), L); 4002 } 4003 4004 if (C.kind == CXCursor_InclusionDirective) { 4005 SourceLocation L 4006 = cxcursor::getCursorInclusionDirective(C)->getSourceRange().getBegin(); 4007 return cxloc::translateSourceLocation(getCursorContext(C), L); 4008 } 4009 4010 if (!clang_isDeclaration(C.kind)) 4011 return clang_getNullLocation(); 4012 4013 Decl *D = getCursorDecl(C); 4014 if (!D) 4015 return clang_getNullLocation(); 4016 4017 SourceLocation Loc = D->getLocation(); 4018 // FIXME: Multiple variables declared in a single declaration 4019 // currently lack the information needed to correctly determine their 4020 // ranges when accounting for the type-specifier. We use context 4021 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 4022 // and if so, whether it is the first decl. 4023 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 4024 if (!cxcursor::isFirstInDeclGroup(C)) 4025 Loc = VD->getLocation(); 4026 } 4027 4028 // For ObjC methods, give the start location of the method name. 4029 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 4030 Loc = MD->getSelectorStartLoc(); 4031 4032 return cxloc::translateSourceLocation(getCursorContext(C), Loc); 4033} 4034 4035} // end extern "C" 4036 4037CXCursor cxcursor::getCursor(CXTranslationUnit TU, SourceLocation SLoc) { 4038 assert(TU); 4039 4040 // Guard against an invalid SourceLocation, or we may assert in one 4041 // of the following calls. 4042 if (SLoc.isInvalid()) 4043 return clang_getNullCursor(); 4044 4045 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4046 4047 // Translate the given source location to make it point at the beginning of 4048 // the token under the cursor. 4049 SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(), 4050 CXXUnit->getASTContext().getLangOpts()); 4051 4052 CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound); 4053 if (SLoc.isValid()) { 4054 GetCursorData ResultData(CXXUnit->getSourceManager(), SLoc, Result); 4055 CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData, 4056 /*VisitPreprocessorLast=*/true, 4057 /*VisitIncludedEntities=*/false, 4058 SourceLocation(SLoc)); 4059 CursorVis.visitFileRegion(); 4060 } 4061 4062 return Result; 4063} 4064 4065static SourceRange getRawCursorExtent(CXCursor C) { 4066 if (clang_isReference(C.kind)) { 4067 switch (C.kind) { 4068 case CXCursor_ObjCSuperClassRef: 4069 return getCursorObjCSuperClassRef(C).second; 4070 4071 case CXCursor_ObjCProtocolRef: 4072 return getCursorObjCProtocolRef(C).second; 4073 4074 case CXCursor_ObjCClassRef: 4075 return getCursorObjCClassRef(C).second; 4076 4077 case CXCursor_TypeRef: 4078 return getCursorTypeRef(C).second; 4079 4080 case CXCursor_TemplateRef: 4081 return getCursorTemplateRef(C).second; 4082 4083 case CXCursor_NamespaceRef: 4084 return getCursorNamespaceRef(C).second; 4085 4086 case CXCursor_MemberRef: 4087 return getCursorMemberRef(C).second; 4088 4089 case CXCursor_CXXBaseSpecifier: 4090 return getCursorCXXBaseSpecifier(C)->getSourceRange(); 4091 4092 case CXCursor_LabelRef: 4093 return getCursorLabelRef(C).second; 4094 4095 case CXCursor_OverloadedDeclRef: 4096 return getCursorOverloadedDeclRef(C).second; 4097 4098 case CXCursor_VariableRef: 4099 return getCursorVariableRef(C).second; 4100 4101 default: 4102 // FIXME: Need a way to enumerate all non-reference cases. 4103 llvm_unreachable("Missed a reference kind"); 4104 } 4105 } 4106 4107 if (clang_isExpression(C.kind)) 4108 return getCursorExpr(C)->getSourceRange(); 4109 4110 if (clang_isStatement(C.kind)) 4111 return getCursorStmt(C)->getSourceRange(); 4112 4113 if (clang_isAttribute(C.kind)) 4114 return getCursorAttr(C)->getRange(); 4115 4116 if (C.kind == CXCursor_PreprocessingDirective) 4117 return cxcursor::getCursorPreprocessingDirective(C); 4118 4119 if (C.kind == CXCursor_MacroExpansion) { 4120 ASTUnit *TU = getCursorASTUnit(C); 4121 SourceRange Range = cxcursor::getCursorMacroExpansion(C)->getSourceRange(); 4122 return TU->mapRangeFromPreamble(Range); 4123 } 4124 4125 if (C.kind == CXCursor_MacroDefinition) { 4126 ASTUnit *TU = getCursorASTUnit(C); 4127 SourceRange Range = cxcursor::getCursorMacroDefinition(C)->getSourceRange(); 4128 return TU->mapRangeFromPreamble(Range); 4129 } 4130 4131 if (C.kind == CXCursor_InclusionDirective) { 4132 ASTUnit *TU = getCursorASTUnit(C); 4133 SourceRange Range = cxcursor::getCursorInclusionDirective(C)->getSourceRange(); 4134 return TU->mapRangeFromPreamble(Range); 4135 } 4136 4137 if (C.kind == CXCursor_TranslationUnit) { 4138 ASTUnit *TU = getCursorASTUnit(C); 4139 FileID MainID = TU->getSourceManager().getMainFileID(); 4140 SourceLocation Start = TU->getSourceManager().getLocForStartOfFile(MainID); 4141 SourceLocation End = TU->getSourceManager().getLocForEndOfFile(MainID); 4142 return SourceRange(Start, End); 4143 } 4144 4145 if (clang_isDeclaration(C.kind)) { 4146 Decl *D = cxcursor::getCursorDecl(C); 4147 if (!D) 4148 return SourceRange(); 4149 4150 SourceRange R = D->getSourceRange(); 4151 // FIXME: Multiple variables declared in a single declaration 4152 // currently lack the information needed to correctly determine their 4153 // ranges when accounting for the type-specifier. We use context 4154 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 4155 // and if so, whether it is the first decl. 4156 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 4157 if (!cxcursor::isFirstInDeclGroup(C)) 4158 R.setBegin(VD->getLocation()); 4159 } 4160 return R; 4161 } 4162 return SourceRange(); 4163} 4164 4165/// \brief Retrieves the "raw" cursor extent, which is then extended to include 4166/// the decl-specifier-seq for declarations. 4167static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) { 4168 if (clang_isDeclaration(C.kind)) { 4169 Decl *D = cxcursor::getCursorDecl(C); 4170 if (!D) 4171 return SourceRange(); 4172 4173 SourceRange R = D->getSourceRange(); 4174 4175 // Adjust the start of the location for declarations preceded by 4176 // declaration specifiers. 4177 SourceLocation StartLoc; 4178 if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) { 4179 if (TypeSourceInfo *TI = DD->getTypeSourceInfo()) 4180 StartLoc = TI->getTypeLoc().getLocStart(); 4181 } else if (TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) { 4182 if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo()) 4183 StartLoc = TI->getTypeLoc().getLocStart(); 4184 } 4185 4186 if (StartLoc.isValid() && R.getBegin().isValid() && 4187 SrcMgr.isBeforeInTranslationUnit(StartLoc, R.getBegin())) 4188 R.setBegin(StartLoc); 4189 4190 // FIXME: Multiple variables declared in a single declaration 4191 // currently lack the information needed to correctly determine their 4192 // ranges when accounting for the type-specifier. We use context 4193 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 4194 // and if so, whether it is the first decl. 4195 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 4196 if (!cxcursor::isFirstInDeclGroup(C)) 4197 R.setBegin(VD->getLocation()); 4198 } 4199 4200 return R; 4201 } 4202 4203 return getRawCursorExtent(C); 4204} 4205 4206extern "C" { 4207 4208CXSourceRange clang_getCursorExtent(CXCursor C) { 4209 SourceRange R = getRawCursorExtent(C); 4210 if (R.isInvalid()) 4211 return clang_getNullRange(); 4212 4213 return cxloc::translateSourceRange(getCursorContext(C), R); 4214} 4215 4216CXCursor clang_getCursorReferenced(CXCursor C) { 4217 if (clang_isInvalid(C.kind)) 4218 return clang_getNullCursor(); 4219 4220 CXTranslationUnit tu = getCursorTU(C); 4221 if (clang_isDeclaration(C.kind)) { 4222 Decl *D = getCursorDecl(C); 4223 if (!D) 4224 return clang_getNullCursor(); 4225 if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) 4226 return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu); 4227 if (ObjCPropertyImplDecl *PropImpl =dyn_cast<ObjCPropertyImplDecl>(D)) 4228 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 4229 return MakeCXCursor(Property, tu); 4230 4231 return C; 4232 } 4233 4234 if (clang_isExpression(C.kind)) { 4235 Expr *E = getCursorExpr(C); 4236 Decl *D = getDeclFromExpr(E); 4237 if (D) { 4238 CXCursor declCursor = MakeCXCursor(D, tu); 4239 declCursor = getSelectorIdentifierCursor(getSelectorIdentifierIndex(C), 4240 declCursor); 4241 return declCursor; 4242 } 4243 4244 if (OverloadExpr *Ovl = dyn_cast_or_null<OverloadExpr>(E)) 4245 return MakeCursorOverloadedDeclRef(Ovl, tu); 4246 4247 return clang_getNullCursor(); 4248 } 4249 4250 if (clang_isStatement(C.kind)) { 4251 Stmt *S = getCursorStmt(C); 4252 if (GotoStmt *Goto = dyn_cast_or_null<GotoStmt>(S)) 4253 if (LabelDecl *label = Goto->getLabel()) 4254 if (LabelStmt *labelS = label->getStmt()) 4255 return MakeCXCursor(labelS, getCursorDecl(C), tu); 4256 4257 return clang_getNullCursor(); 4258 } 4259 4260 if (C.kind == CXCursor_MacroExpansion) { 4261 if (MacroDefinition *Def = getCursorMacroExpansion(C)->getDefinition()) 4262 return MakeMacroDefinitionCursor(Def, tu); 4263 } 4264 4265 if (!clang_isReference(C.kind)) 4266 return clang_getNullCursor(); 4267 4268 switch (C.kind) { 4269 case CXCursor_ObjCSuperClassRef: 4270 return MakeCXCursor(getCursorObjCSuperClassRef(C).first, tu); 4271 4272 case CXCursor_ObjCProtocolRef: { 4273 ObjCProtocolDecl *Prot = getCursorObjCProtocolRef(C).first; 4274 if (ObjCProtocolDecl *Def = Prot->getDefinition()) 4275 return MakeCXCursor(Def, tu); 4276 4277 return MakeCXCursor(Prot, tu); 4278 } 4279 4280 case CXCursor_ObjCClassRef: { 4281 ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first; 4282 if (ObjCInterfaceDecl *Def = Class->getDefinition()) 4283 return MakeCXCursor(Def, tu); 4284 4285 return MakeCXCursor(Class, tu); 4286 } 4287 4288 case CXCursor_TypeRef: 4289 return MakeCXCursor(getCursorTypeRef(C).first, tu ); 4290 4291 case CXCursor_TemplateRef: 4292 return MakeCXCursor(getCursorTemplateRef(C).first, tu ); 4293 4294 case CXCursor_NamespaceRef: 4295 return MakeCXCursor(getCursorNamespaceRef(C).first, tu ); 4296 4297 case CXCursor_MemberRef: 4298 return MakeCXCursor(getCursorMemberRef(C).first, tu ); 4299 4300 case CXCursor_CXXBaseSpecifier: { 4301 CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C); 4302 return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(), 4303 tu )); 4304 } 4305 4306 case CXCursor_LabelRef: 4307 // FIXME: We end up faking the "parent" declaration here because we 4308 // don't want to make CXCursor larger. 4309 return MakeCXCursor(getCursorLabelRef(C).first, 4310 static_cast<ASTUnit*>(tu->TUData)->getASTContext() 4311 .getTranslationUnitDecl(), 4312 tu); 4313 4314 case CXCursor_OverloadedDeclRef: 4315 return C; 4316 4317 case CXCursor_VariableRef: 4318 return MakeCXCursor(getCursorVariableRef(C).first, tu); 4319 4320 default: 4321 // We would prefer to enumerate all non-reference cursor kinds here. 4322 llvm_unreachable("Unhandled reference cursor kind"); 4323 } 4324} 4325 4326CXCursor clang_getCursorDefinition(CXCursor C) { 4327 if (clang_isInvalid(C.kind)) 4328 return clang_getNullCursor(); 4329 4330 CXTranslationUnit TU = getCursorTU(C); 4331 4332 bool WasReference = false; 4333 if (clang_isReference(C.kind) || clang_isExpression(C.kind)) { 4334 C = clang_getCursorReferenced(C); 4335 WasReference = true; 4336 } 4337 4338 if (C.kind == CXCursor_MacroExpansion) 4339 return clang_getCursorReferenced(C); 4340 4341 if (!clang_isDeclaration(C.kind)) 4342 return clang_getNullCursor(); 4343 4344 Decl *D = getCursorDecl(C); 4345 if (!D) 4346 return clang_getNullCursor(); 4347 4348 switch (D->getKind()) { 4349 // Declaration kinds that don't really separate the notions of 4350 // declaration and definition. 4351 case Decl::Namespace: 4352 case Decl::Typedef: 4353 case Decl::TypeAlias: 4354 case Decl::TypeAliasTemplate: 4355 case Decl::TemplateTypeParm: 4356 case Decl::EnumConstant: 4357 case Decl::Field: 4358 case Decl::IndirectField: 4359 case Decl::ObjCIvar: 4360 case Decl::ObjCAtDefsField: 4361 case Decl::ImplicitParam: 4362 case Decl::ParmVar: 4363 case Decl::NonTypeTemplateParm: 4364 case Decl::TemplateTemplateParm: 4365 case Decl::ObjCCategoryImpl: 4366 case Decl::ObjCImplementation: 4367 case Decl::AccessSpec: 4368 case Decl::LinkageSpec: 4369 case Decl::ObjCPropertyImpl: 4370 case Decl::FileScopeAsm: 4371 case Decl::StaticAssert: 4372 case Decl::Block: 4373 case Decl::Label: // FIXME: Is this right?? 4374 case Decl::ClassScopeFunctionSpecialization: 4375 case Decl::Import: 4376 return C; 4377 4378 // Declaration kinds that don't make any sense here, but are 4379 // nonetheless harmless. 4380 case Decl::TranslationUnit: 4381 break; 4382 4383 // Declaration kinds for which the definition is not resolvable. 4384 case Decl::UnresolvedUsingTypename: 4385 case Decl::UnresolvedUsingValue: 4386 break; 4387 4388 case Decl::UsingDirective: 4389 return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(), 4390 TU); 4391 4392 case Decl::NamespaceAlias: 4393 return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), TU); 4394 4395 case Decl::Enum: 4396 case Decl::Record: 4397 case Decl::CXXRecord: 4398 case Decl::ClassTemplateSpecialization: 4399 case Decl::ClassTemplatePartialSpecialization: 4400 if (TagDecl *Def = cast<TagDecl>(D)->getDefinition()) 4401 return MakeCXCursor(Def, TU); 4402 return clang_getNullCursor(); 4403 4404 case Decl::Function: 4405 case Decl::CXXMethod: 4406 case Decl::CXXConstructor: 4407 case Decl::CXXDestructor: 4408 case Decl::CXXConversion: { 4409 const FunctionDecl *Def = 0; 4410 if (cast<FunctionDecl>(D)->getBody(Def)) 4411 return MakeCXCursor(const_cast<FunctionDecl *>(Def), TU); 4412 return clang_getNullCursor(); 4413 } 4414 4415 case Decl::Var: { 4416 // Ask the variable if it has a definition. 4417 if (VarDecl *Def = cast<VarDecl>(D)->getDefinition()) 4418 return MakeCXCursor(Def, TU); 4419 return clang_getNullCursor(); 4420 } 4421 4422 case Decl::FunctionTemplate: { 4423 const FunctionDecl *Def = 0; 4424 if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def)) 4425 return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU); 4426 return clang_getNullCursor(); 4427 } 4428 4429 case Decl::ClassTemplate: { 4430 if (RecordDecl *Def = cast<ClassTemplateDecl>(D)->getTemplatedDecl() 4431 ->getDefinition()) 4432 return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(), 4433 TU); 4434 return clang_getNullCursor(); 4435 } 4436 4437 case Decl::Using: 4438 return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D), 4439 D->getLocation(), TU); 4440 4441 case Decl::UsingShadow: 4442 return clang_getCursorDefinition( 4443 MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(), 4444 TU)); 4445 4446 case Decl::ObjCMethod: { 4447 ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D); 4448 if (Method->isThisDeclarationADefinition()) 4449 return C; 4450 4451 // Dig out the method definition in the associated 4452 // @implementation, if we have it. 4453 // FIXME: The ASTs should make finding the definition easier. 4454 if (ObjCInterfaceDecl *Class 4455 = dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) 4456 if (ObjCImplementationDecl *ClassImpl = Class->getImplementation()) 4457 if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(), 4458 Method->isInstanceMethod())) 4459 if (Def->isThisDeclarationADefinition()) 4460 return MakeCXCursor(Def, TU); 4461 4462 return clang_getNullCursor(); 4463 } 4464 4465 case Decl::ObjCCategory: 4466 if (ObjCCategoryImplDecl *Impl 4467 = cast<ObjCCategoryDecl>(D)->getImplementation()) 4468 return MakeCXCursor(Impl, TU); 4469 return clang_getNullCursor(); 4470 4471 case Decl::ObjCProtocol: 4472 if (ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(D)->getDefinition()) 4473 return MakeCXCursor(Def, TU); 4474 return clang_getNullCursor(); 4475 4476 case Decl::ObjCInterface: { 4477 // There are two notions of a "definition" for an Objective-C 4478 // class: the interface and its implementation. When we resolved a 4479 // reference to an Objective-C class, produce the @interface as 4480 // the definition; when we were provided with the interface, 4481 // produce the @implementation as the definition. 4482 ObjCInterfaceDecl *IFace = cast<ObjCInterfaceDecl>(D); 4483 if (WasReference) { 4484 if (ObjCInterfaceDecl *Def = IFace->getDefinition()) 4485 return MakeCXCursor(Def, TU); 4486 } else if (ObjCImplementationDecl *Impl = IFace->getImplementation()) 4487 return MakeCXCursor(Impl, TU); 4488 return clang_getNullCursor(); 4489 } 4490 4491 case Decl::ObjCProperty: 4492 // FIXME: We don't really know where to find the 4493 // ObjCPropertyImplDecls that implement this property. 4494 return clang_getNullCursor(); 4495 4496 case Decl::ObjCCompatibleAlias: 4497 if (ObjCInterfaceDecl *Class 4498 = cast<ObjCCompatibleAliasDecl>(D)->getClassInterface()) 4499 if (ObjCInterfaceDecl *Def = Class->getDefinition()) 4500 return MakeCXCursor(Def, TU); 4501 4502 return clang_getNullCursor(); 4503 4504 case Decl::Friend: 4505 if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl()) 4506 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 4507 return clang_getNullCursor(); 4508 4509 case Decl::FriendTemplate: 4510 if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl()) 4511 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 4512 return clang_getNullCursor(); 4513 } 4514 4515 return clang_getNullCursor(); 4516} 4517 4518unsigned clang_isCursorDefinition(CXCursor C) { 4519 if (!clang_isDeclaration(C.kind)) 4520 return 0; 4521 4522 return clang_getCursorDefinition(C) == C; 4523} 4524 4525CXCursor clang_getCanonicalCursor(CXCursor C) { 4526 if (!clang_isDeclaration(C.kind)) 4527 return C; 4528 4529 if (Decl *D = getCursorDecl(C)) { 4530 if (ObjCCategoryImplDecl *CatImplD = dyn_cast<ObjCCategoryImplDecl>(D)) 4531 if (ObjCCategoryDecl *CatD = CatImplD->getCategoryDecl()) 4532 return MakeCXCursor(CatD, getCursorTU(C)); 4533 4534 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 4535 if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) 4536 return MakeCXCursor(IFD, getCursorTU(C)); 4537 4538 return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C)); 4539 } 4540 4541 return C; 4542} 4543 4544int clang_Cursor_getObjCSelectorIndex(CXCursor cursor) { 4545 return cxcursor::getSelectorIdentifierIndexAndLoc(cursor).first; 4546} 4547 4548unsigned clang_getNumOverloadedDecls(CXCursor C) { 4549 if (C.kind != CXCursor_OverloadedDeclRef) 4550 return 0; 4551 4552 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 4553 if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>()) 4554 return E->getNumDecls(); 4555 4556 if (OverloadedTemplateStorage *S 4557 = Storage.dyn_cast<OverloadedTemplateStorage*>()) 4558 return S->size(); 4559 4560 Decl *D = Storage.get<Decl*>(); 4561 if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) 4562 return Using->shadow_size(); 4563 4564 return 0; 4565} 4566 4567CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) { 4568 if (cursor.kind != CXCursor_OverloadedDeclRef) 4569 return clang_getNullCursor(); 4570 4571 if (index >= clang_getNumOverloadedDecls(cursor)) 4572 return clang_getNullCursor(); 4573 4574 CXTranslationUnit TU = getCursorTU(cursor); 4575 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first; 4576 if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>()) 4577 return MakeCXCursor(E->decls_begin()[index], TU); 4578 4579 if (OverloadedTemplateStorage *S 4580 = Storage.dyn_cast<OverloadedTemplateStorage*>()) 4581 return MakeCXCursor(S->begin()[index], TU); 4582 4583 Decl *D = Storage.get<Decl*>(); 4584 if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) { 4585 // FIXME: This is, unfortunately, linear time. 4586 UsingDecl::shadow_iterator Pos = Using->shadow_begin(); 4587 std::advance(Pos, index); 4588 return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU); 4589 } 4590 4591 return clang_getNullCursor(); 4592} 4593 4594void clang_getDefinitionSpellingAndExtent(CXCursor C, 4595 const char **startBuf, 4596 const char **endBuf, 4597 unsigned *startLine, 4598 unsigned *startColumn, 4599 unsigned *endLine, 4600 unsigned *endColumn) { 4601 assert(getCursorDecl(C) && "CXCursor has null decl"); 4602 NamedDecl *ND = static_cast<NamedDecl *>(getCursorDecl(C)); 4603 FunctionDecl *FD = dyn_cast<FunctionDecl>(ND); 4604 CompoundStmt *Body = dyn_cast<CompoundStmt>(FD->getBody()); 4605 4606 SourceManager &SM = FD->getASTContext().getSourceManager(); 4607 *startBuf = SM.getCharacterData(Body->getLBracLoc()); 4608 *endBuf = SM.getCharacterData(Body->getRBracLoc()); 4609 *startLine = SM.getSpellingLineNumber(Body->getLBracLoc()); 4610 *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc()); 4611 *endLine = SM.getSpellingLineNumber(Body->getRBracLoc()); 4612 *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc()); 4613} 4614 4615 4616CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags, 4617 unsigned PieceIndex) { 4618 RefNamePieces Pieces; 4619 4620 switch (C.kind) { 4621 case CXCursor_MemberRefExpr: 4622 if (MemberExpr *E = dyn_cast<MemberExpr>(getCursorExpr(C))) 4623 Pieces = buildPieces(NameFlags, true, E->getMemberNameInfo(), 4624 E->getQualifierLoc().getSourceRange()); 4625 break; 4626 4627 case CXCursor_DeclRefExpr: 4628 if (DeclRefExpr *E = dyn_cast<DeclRefExpr>(getCursorExpr(C))) 4629 Pieces = buildPieces(NameFlags, false, E->getNameInfo(), 4630 E->getQualifierLoc().getSourceRange(), 4631 E->getOptionalExplicitTemplateArgs()); 4632 break; 4633 4634 case CXCursor_CallExpr: 4635 if (CXXOperatorCallExpr *OCE = 4636 dyn_cast<CXXOperatorCallExpr>(getCursorExpr(C))) { 4637 Expr *Callee = OCE->getCallee(); 4638 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee)) 4639 Callee = ICE->getSubExpr(); 4640 4641 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) 4642 Pieces = buildPieces(NameFlags, false, DRE->getNameInfo(), 4643 DRE->getQualifierLoc().getSourceRange()); 4644 } 4645 break; 4646 4647 default: 4648 break; 4649 } 4650 4651 if (Pieces.empty()) { 4652 if (PieceIndex == 0) 4653 return clang_getCursorExtent(C); 4654 } else if (PieceIndex < Pieces.size()) { 4655 SourceRange R = Pieces[PieceIndex]; 4656 if (R.isValid()) 4657 return cxloc::translateSourceRange(getCursorContext(C), R); 4658 } 4659 4660 return clang_getNullRange(); 4661} 4662 4663void clang_enableStackTraces(void) { 4664 llvm::sys::PrintStackTraceOnErrorSignal(); 4665} 4666 4667void clang_executeOnThread(void (*fn)(void*), void *user_data, 4668 unsigned stack_size) { 4669 llvm::llvm_execute_on_thread(fn, user_data, stack_size); 4670} 4671 4672} // end: extern "C" 4673 4674//===----------------------------------------------------------------------===// 4675// Token-based Operations. 4676//===----------------------------------------------------------------------===// 4677 4678/* CXToken layout: 4679 * int_data[0]: a CXTokenKind 4680 * int_data[1]: starting token location 4681 * int_data[2]: token length 4682 * int_data[3]: reserved 4683 * ptr_data: for identifiers and keywords, an IdentifierInfo*. 4684 * otherwise unused. 4685 */ 4686extern "C" { 4687 4688CXTokenKind clang_getTokenKind(CXToken CXTok) { 4689 return static_cast<CXTokenKind>(CXTok.int_data[0]); 4690} 4691 4692CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) { 4693 switch (clang_getTokenKind(CXTok)) { 4694 case CXToken_Identifier: 4695 case CXToken_Keyword: 4696 // We know we have an IdentifierInfo*, so use that. 4697 return createCXString(static_cast<IdentifierInfo *>(CXTok.ptr_data) 4698 ->getNameStart()); 4699 4700 case CXToken_Literal: { 4701 // We have stashed the starting pointer in the ptr_data field. Use it. 4702 const char *Text = static_cast<const char *>(CXTok.ptr_data); 4703 return createCXString(StringRef(Text, CXTok.int_data[2])); 4704 } 4705 4706 case CXToken_Punctuation: 4707 case CXToken_Comment: 4708 break; 4709 } 4710 4711 // We have to find the starting buffer pointer the hard way, by 4712 // deconstructing the source location. 4713 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4714 if (!CXXUnit) 4715 return createCXString(""); 4716 4717 SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]); 4718 std::pair<FileID, unsigned> LocInfo 4719 = CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc); 4720 bool Invalid = false; 4721 StringRef Buffer 4722 = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid); 4723 if (Invalid) 4724 return createCXString(""); 4725 4726 return createCXString(Buffer.substr(LocInfo.second, CXTok.int_data[2])); 4727} 4728 4729CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) { 4730 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4731 if (!CXXUnit) 4732 return clang_getNullLocation(); 4733 4734 return cxloc::translateSourceLocation(CXXUnit->getASTContext(), 4735 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 4736} 4737 4738CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) { 4739 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4740 if (!CXXUnit) 4741 return clang_getNullRange(); 4742 4743 return cxloc::translateSourceRange(CXXUnit->getASTContext(), 4744 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 4745} 4746 4747static void getTokens(ASTUnit *CXXUnit, SourceRange Range, 4748 SmallVectorImpl<CXToken> &CXTokens) { 4749 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 4750 std::pair<FileID, unsigned> BeginLocInfo 4751 = SourceMgr.getDecomposedLoc(Range.getBegin()); 4752 std::pair<FileID, unsigned> EndLocInfo 4753 = SourceMgr.getDecomposedLoc(Range.getEnd()); 4754 4755 // Cannot tokenize across files. 4756 if (BeginLocInfo.first != EndLocInfo.first) 4757 return; 4758 4759 // Create a lexer 4760 bool Invalid = false; 4761 StringRef Buffer 4762 = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid); 4763 if (Invalid) 4764 return; 4765 4766 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 4767 CXXUnit->getASTContext().getLangOpts(), 4768 Buffer.begin(), Buffer.data() + BeginLocInfo.second, Buffer.end()); 4769 Lex.SetCommentRetentionState(true); 4770 4771 // Lex tokens until we hit the end of the range. 4772 const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second; 4773 Token Tok; 4774 bool previousWasAt = false; 4775 do { 4776 // Lex the next token 4777 Lex.LexFromRawLexer(Tok); 4778 if (Tok.is(tok::eof)) 4779 break; 4780 4781 // Initialize the CXToken. 4782 CXToken CXTok; 4783 4784 // - Common fields 4785 CXTok.int_data[1] = Tok.getLocation().getRawEncoding(); 4786 CXTok.int_data[2] = Tok.getLength(); 4787 CXTok.int_data[3] = 0; 4788 4789 // - Kind-specific fields 4790 if (Tok.isLiteral()) { 4791 CXTok.int_data[0] = CXToken_Literal; 4792 CXTok.ptr_data = (void *)Tok.getLiteralData(); 4793 } else if (Tok.is(tok::raw_identifier)) { 4794 // Lookup the identifier to determine whether we have a keyword. 4795 IdentifierInfo *II 4796 = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok); 4797 4798 if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) { 4799 CXTok.int_data[0] = CXToken_Keyword; 4800 } 4801 else { 4802 CXTok.int_data[0] = Tok.is(tok::identifier) 4803 ? CXToken_Identifier 4804 : CXToken_Keyword; 4805 } 4806 CXTok.ptr_data = II; 4807 } else if (Tok.is(tok::comment)) { 4808 CXTok.int_data[0] = CXToken_Comment; 4809 CXTok.ptr_data = 0; 4810 } else { 4811 CXTok.int_data[0] = CXToken_Punctuation; 4812 CXTok.ptr_data = 0; 4813 } 4814 CXTokens.push_back(CXTok); 4815 previousWasAt = Tok.is(tok::at); 4816 } while (Lex.getBufferLocation() <= EffectiveBufferEnd); 4817} 4818 4819void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range, 4820 CXToken **Tokens, unsigned *NumTokens) { 4821 if (Tokens) 4822 *Tokens = 0; 4823 if (NumTokens) 4824 *NumTokens = 0; 4825 4826 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4827 if (!CXXUnit || !Tokens || !NumTokens) 4828 return; 4829 4830 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 4831 4832 SourceRange R = cxloc::translateCXSourceRange(Range); 4833 if (R.isInvalid()) 4834 return; 4835 4836 SmallVector<CXToken, 32> CXTokens; 4837 getTokens(CXXUnit, R, CXTokens); 4838 4839 if (CXTokens.empty()) 4840 return; 4841 4842 *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size()); 4843 memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size()); 4844 *NumTokens = CXTokens.size(); 4845} 4846 4847void clang_disposeTokens(CXTranslationUnit TU, 4848 CXToken *Tokens, unsigned NumTokens) { 4849 free(Tokens); 4850} 4851 4852} // end: extern "C" 4853 4854//===----------------------------------------------------------------------===// 4855// Token annotation APIs. 4856//===----------------------------------------------------------------------===// 4857 4858typedef llvm::DenseMap<unsigned, CXCursor> AnnotateTokensData; 4859static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 4860 CXCursor parent, 4861 CXClientData client_data); 4862static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor, 4863 CXClientData client_data); 4864 4865namespace { 4866class AnnotateTokensWorker { 4867 AnnotateTokensData &Annotated; 4868 CXToken *Tokens; 4869 CXCursor *Cursors; 4870 unsigned NumTokens; 4871 unsigned TokIdx; 4872 unsigned PreprocessingTokIdx; 4873 CursorVisitor AnnotateVis; 4874 SourceManager &SrcMgr; 4875 bool HasContextSensitiveKeywords; 4876 4877 struct PostChildrenInfo { 4878 CXCursor Cursor; 4879 SourceRange CursorRange; 4880 unsigned BeforeChildrenTokenIdx; 4881 }; 4882 llvm::SmallVector<PostChildrenInfo, 8> PostChildrenInfos; 4883 4884 bool MoreTokens() const { return TokIdx < NumTokens; } 4885 unsigned NextToken() const { return TokIdx; } 4886 void AdvanceToken() { ++TokIdx; } 4887 SourceLocation GetTokenLoc(unsigned tokI) { 4888 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]); 4889 } 4890 bool isFunctionMacroToken(unsigned tokI) const { 4891 return Tokens[tokI].int_data[3] != 0; 4892 } 4893 SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const { 4894 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[3]); 4895 } 4896 4897 void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange); 4898 void annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult, 4899 SourceRange); 4900 4901public: 4902 AnnotateTokensWorker(AnnotateTokensData &annotated, 4903 CXToken *tokens, CXCursor *cursors, unsigned numTokens, 4904 CXTranslationUnit tu, SourceRange RegionOfInterest) 4905 : Annotated(annotated), Tokens(tokens), Cursors(cursors), 4906 NumTokens(numTokens), TokIdx(0), PreprocessingTokIdx(0), 4907 AnnotateVis(tu, 4908 AnnotateTokensVisitor, this, 4909 /*VisitPreprocessorLast=*/true, 4910 /*VisitIncludedEntities=*/false, 4911 RegionOfInterest, 4912 /*VisitDeclsOnly=*/false, 4913 AnnotateTokensPostChildrenVisitor), 4914 SrcMgr(static_cast<ASTUnit*>(tu->TUData)->getSourceManager()), 4915 HasContextSensitiveKeywords(false) { } 4916 4917 void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); } 4918 enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent); 4919 bool postVisitChildren(CXCursor cursor); 4920 void AnnotateTokens(); 4921 4922 /// \brief Determine whether the annotator saw any cursors that have 4923 /// context-sensitive keywords. 4924 bool hasContextSensitiveKeywords() const { 4925 return HasContextSensitiveKeywords; 4926 } 4927 4928 ~AnnotateTokensWorker() { 4929 assert(PostChildrenInfos.empty()); 4930 } 4931}; 4932} 4933 4934void AnnotateTokensWorker::AnnotateTokens() { 4935 // Walk the AST within the region of interest, annotating tokens 4936 // along the way. 4937 AnnotateVis.visitFileRegion(); 4938 4939 for (unsigned I = 0 ; I < TokIdx ; ++I) { 4940 AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]); 4941 if (Pos != Annotated.end() && 4942 (clang_isInvalid(Cursors[I].kind) || 4943 Pos->second.kind != CXCursor_PreprocessingDirective)) 4944 Cursors[I] = Pos->second; 4945 } 4946 4947 // Finish up annotating any tokens left. 4948 if (!MoreTokens()) 4949 return; 4950 4951 const CXCursor &C = clang_getNullCursor(); 4952 for (unsigned I = TokIdx ; I < NumTokens ; ++I) { 4953 if (I < PreprocessingTokIdx && clang_isPreprocessing(Cursors[I].kind)) 4954 continue; 4955 4956 AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]); 4957 Cursors[I] = (Pos == Annotated.end()) ? C : Pos->second; 4958 } 4959} 4960 4961/// \brief It annotates and advances tokens with a cursor until the comparison 4962//// between the cursor location and the source range is the same as 4963/// \arg compResult. 4964/// 4965/// Pass RangeBefore to annotate tokens with a cursor until a range is reached. 4966/// Pass RangeOverlap to annotate tokens inside a range. 4967void AnnotateTokensWorker::annotateAndAdvanceTokens(CXCursor updateC, 4968 RangeComparisonResult compResult, 4969 SourceRange range) { 4970 while (MoreTokens()) { 4971 const unsigned I = NextToken(); 4972 if (isFunctionMacroToken(I)) 4973 return annotateAndAdvanceFunctionMacroTokens(updateC, compResult, range); 4974 4975 SourceLocation TokLoc = GetTokenLoc(I); 4976 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) { 4977 Cursors[I] = updateC; 4978 AdvanceToken(); 4979 continue; 4980 } 4981 break; 4982 } 4983} 4984 4985/// \brief Special annotation handling for macro argument tokens. 4986void AnnotateTokensWorker::annotateAndAdvanceFunctionMacroTokens( 4987 CXCursor updateC, 4988 RangeComparisonResult compResult, 4989 SourceRange range) { 4990 assert(MoreTokens()); 4991 assert(isFunctionMacroToken(NextToken()) && 4992 "Should be called only for macro arg tokens"); 4993 4994 // This works differently than annotateAndAdvanceTokens; because expanded 4995 // macro arguments can have arbitrary translation-unit source order, we do not 4996 // advance the token index one by one until a token fails the range test. 4997 // We only advance once past all of the macro arg tokens if all of them 4998 // pass the range test. If one of them fails we keep the token index pointing 4999 // at the start of the macro arg tokens so that the failing token will be 5000 // annotated by a subsequent annotation try. 5001 5002 bool atLeastOneCompFail = false; 5003 5004 unsigned I = NextToken(); 5005 for (; I < NumTokens && isFunctionMacroToken(I); ++I) { 5006 SourceLocation TokLoc = getFunctionMacroTokenLoc(I); 5007 if (TokLoc.isFileID()) 5008 continue; // not macro arg token, it's parens or comma. 5009 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) { 5010 if (clang_isInvalid(clang_getCursorKind(Cursors[I]))) 5011 Cursors[I] = updateC; 5012 } else 5013 atLeastOneCompFail = true; 5014 } 5015 5016 if (!atLeastOneCompFail) 5017 TokIdx = I; // All of the tokens were handled, advance beyond all of them. 5018} 5019 5020enum CXChildVisitResult 5021AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) { 5022 CXSourceLocation Loc = clang_getCursorLocation(cursor); 5023 SourceRange cursorRange = getRawCursorExtent(cursor); 5024 if (cursorRange.isInvalid()) 5025 return CXChildVisit_Recurse; 5026 5027 if (!HasContextSensitiveKeywords) { 5028 // Objective-C properties can have context-sensitive keywords. 5029 if (cursor.kind == CXCursor_ObjCPropertyDecl) { 5030 if (ObjCPropertyDecl *Property 5031 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(cursor))) 5032 HasContextSensitiveKeywords = Property->getPropertyAttributesAsWritten() != 0; 5033 } 5034 // Objective-C methods can have context-sensitive keywords. 5035 else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl || 5036 cursor.kind == CXCursor_ObjCClassMethodDecl) { 5037 if (ObjCMethodDecl *Method 5038 = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) { 5039 if (Method->getObjCDeclQualifier()) 5040 HasContextSensitiveKeywords = true; 5041 else { 5042 for (ObjCMethodDecl::param_iterator P = Method->param_begin(), 5043 PEnd = Method->param_end(); 5044 P != PEnd; ++P) { 5045 if ((*P)->getObjCDeclQualifier()) { 5046 HasContextSensitiveKeywords = true; 5047 break; 5048 } 5049 } 5050 } 5051 } 5052 } 5053 // C++ methods can have context-sensitive keywords. 5054 else if (cursor.kind == CXCursor_CXXMethod) { 5055 if (CXXMethodDecl *Method 5056 = dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(cursor))) { 5057 if (Method->hasAttr<FinalAttr>() || Method->hasAttr<OverrideAttr>()) 5058 HasContextSensitiveKeywords = true; 5059 } 5060 } 5061 // C++ classes can have context-sensitive keywords. 5062 else if (cursor.kind == CXCursor_StructDecl || 5063 cursor.kind == CXCursor_ClassDecl || 5064 cursor.kind == CXCursor_ClassTemplate || 5065 cursor.kind == CXCursor_ClassTemplatePartialSpecialization) { 5066 if (Decl *D = getCursorDecl(cursor)) 5067 if (D->hasAttr<FinalAttr>()) 5068 HasContextSensitiveKeywords = true; 5069 } 5070 } 5071 5072 if (clang_isPreprocessing(cursor.kind)) { 5073 // For macro expansions, just note where the beginning of the macro 5074 // expansion occurs. 5075 if (cursor.kind == CXCursor_MacroExpansion) { 5076 Annotated[Loc.int_data] = cursor; 5077 return CXChildVisit_Recurse; 5078 } 5079 5080 // Items in the preprocessing record are kept separate from items in 5081 // declarations, so we keep a separate token index. 5082 unsigned SavedTokIdx = TokIdx; 5083 TokIdx = PreprocessingTokIdx; 5084 5085 // Skip tokens up until we catch up to the beginning of the preprocessing 5086 // entry. 5087 while (MoreTokens()) { 5088 const unsigned I = NextToken(); 5089 SourceLocation TokLoc = GetTokenLoc(I); 5090 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 5091 case RangeBefore: 5092 AdvanceToken(); 5093 continue; 5094 case RangeAfter: 5095 case RangeOverlap: 5096 break; 5097 } 5098 break; 5099 } 5100 5101 // Look at all of the tokens within this range. 5102 while (MoreTokens()) { 5103 const unsigned I = NextToken(); 5104 SourceLocation TokLoc = GetTokenLoc(I); 5105 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 5106 case RangeBefore: 5107 llvm_unreachable("Infeasible"); 5108 case RangeAfter: 5109 break; 5110 case RangeOverlap: 5111 Cursors[I] = cursor; 5112 AdvanceToken(); 5113 continue; 5114 } 5115 break; 5116 } 5117 5118 // Save the preprocessing token index; restore the non-preprocessing 5119 // token index. 5120 PreprocessingTokIdx = TokIdx; 5121 TokIdx = SavedTokIdx; 5122 return CXChildVisit_Recurse; 5123 } 5124 5125 if (cursorRange.isInvalid()) 5126 return CXChildVisit_Continue; 5127 5128 SourceLocation L = SourceLocation::getFromRawEncoding(Loc.int_data); 5129 5130 // Adjust the annotated range based specific declarations. 5131 const enum CXCursorKind cursorK = clang_getCursorKind(cursor); 5132 if (clang_isDeclaration(cursorK)) { 5133 Decl *D = cxcursor::getCursorDecl(cursor); 5134 5135 SourceLocation StartLoc; 5136 if (const DeclaratorDecl *DD = dyn_cast_or_null<DeclaratorDecl>(D)) { 5137 if (TypeSourceInfo *TI = DD->getTypeSourceInfo()) 5138 StartLoc = TI->getTypeLoc().getLocStart(); 5139 } else if (TypedefDecl *Typedef = dyn_cast_or_null<TypedefDecl>(D)) { 5140 if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo()) 5141 StartLoc = TI->getTypeLoc().getLocStart(); 5142 } 5143 5144 if (StartLoc.isValid() && L.isValid() && 5145 SrcMgr.isBeforeInTranslationUnit(StartLoc, L)) 5146 cursorRange.setBegin(StartLoc); 5147 } 5148 5149 // If the location of the cursor occurs within a macro instantiation, record 5150 // the spelling location of the cursor in our annotation map. We can then 5151 // paper over the token labelings during a post-processing step to try and 5152 // get cursor mappings for tokens that are the *arguments* of a macro 5153 // instantiation. 5154 if (L.isMacroID()) { 5155 unsigned rawEncoding = SrcMgr.getSpellingLoc(L).getRawEncoding(); 5156 // Only invalidate the old annotation if it isn't part of a preprocessing 5157 // directive. Here we assume that the default construction of CXCursor 5158 // results in CXCursor.kind being an initialized value (i.e., 0). If 5159 // this isn't the case, we can fix by doing lookup + insertion. 5160 5161 CXCursor &oldC = Annotated[rawEncoding]; 5162 if (!clang_isPreprocessing(oldC.kind)) 5163 oldC = cursor; 5164 } 5165 5166 const enum CXCursorKind K = clang_getCursorKind(parent); 5167 const CXCursor updateC = 5168 (clang_isInvalid(K) || K == CXCursor_TranslationUnit) 5169 ? clang_getNullCursor() : parent; 5170 5171 annotateAndAdvanceTokens(updateC, RangeBefore, cursorRange); 5172 5173 // Avoid having the cursor of an expression "overwrite" the annotation of the 5174 // variable declaration that it belongs to. 5175 // This can happen for C++ constructor expressions whose range generally 5176 // include the variable declaration, e.g.: 5177 // MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor. 5178 if (clang_isExpression(cursorK)) { 5179 Expr *E = getCursorExpr(cursor); 5180 if (Decl *D = getCursorParentDecl(cursor)) { 5181 const unsigned I = NextToken(); 5182 if (E->getLocStart().isValid() && D->getLocation().isValid() && 5183 E->getLocStart() == D->getLocation() && 5184 E->getLocStart() == GetTokenLoc(I)) { 5185 Cursors[I] = updateC; 5186 AdvanceToken(); 5187 } 5188 } 5189 } 5190 5191 // Before recursing into the children keep some state that we are going 5192 // to use in the AnnotateTokensWorker::postVisitChildren callback to do some 5193 // extra work after the child nodes are visited. 5194 // Note that we don't call VisitChildren here to avoid traversing statements 5195 // code-recursively which can blow the stack. 5196 5197 PostChildrenInfo Info; 5198 Info.Cursor = cursor; 5199 Info.CursorRange = cursorRange; 5200 Info.BeforeChildrenTokenIdx = NextToken(); 5201 PostChildrenInfos.push_back(Info); 5202 5203 return CXChildVisit_Recurse; 5204} 5205 5206bool AnnotateTokensWorker::postVisitChildren(CXCursor cursor) { 5207 if (PostChildrenInfos.empty()) 5208 return false; 5209 const PostChildrenInfo &Info = PostChildrenInfos.back(); 5210 if (!clang_equalCursors(Info.Cursor, cursor)) 5211 return false; 5212 5213 const unsigned BeforeChildren = Info.BeforeChildrenTokenIdx; 5214 const unsigned AfterChildren = NextToken(); 5215 SourceRange cursorRange = Info.CursorRange; 5216 5217 // Scan the tokens that are at the end of the cursor, but are not captured 5218 // but the child cursors. 5219 annotateAndAdvanceTokens(cursor, RangeOverlap, cursorRange); 5220 5221 // Scan the tokens that are at the beginning of the cursor, but are not 5222 // capture by the child cursors. 5223 for (unsigned I = BeforeChildren; I != AfterChildren; ++I) { 5224 if (!clang_isInvalid(clang_getCursorKind(Cursors[I]))) 5225 break; 5226 5227 Cursors[I] = cursor; 5228 } 5229 5230 PostChildrenInfos.pop_back(); 5231 return false; 5232} 5233 5234static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 5235 CXCursor parent, 5236 CXClientData client_data) { 5237 return static_cast<AnnotateTokensWorker*>(client_data)->Visit(cursor, parent); 5238} 5239 5240static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor, 5241 CXClientData client_data) { 5242 return static_cast<AnnotateTokensWorker*>(client_data)-> 5243 postVisitChildren(cursor); 5244} 5245 5246namespace { 5247 5248/// \brief Uses the macro expansions in the preprocessing record to find 5249/// and mark tokens that are macro arguments. This info is used by the 5250/// AnnotateTokensWorker. 5251class MarkMacroArgTokensVisitor { 5252 SourceManager &SM; 5253 CXToken *Tokens; 5254 unsigned NumTokens; 5255 unsigned CurIdx; 5256 5257public: 5258 MarkMacroArgTokensVisitor(SourceManager &SM, 5259 CXToken *tokens, unsigned numTokens) 5260 : SM(SM), Tokens(tokens), NumTokens(numTokens), CurIdx(0) { } 5261 5262 CXChildVisitResult visit(CXCursor cursor, CXCursor parent) { 5263 if (cursor.kind != CXCursor_MacroExpansion) 5264 return CXChildVisit_Continue; 5265 5266 SourceRange macroRange = getCursorMacroExpansion(cursor)->getSourceRange(); 5267 if (macroRange.getBegin() == macroRange.getEnd()) 5268 return CXChildVisit_Continue; // it's not a function macro. 5269 5270 for (; CurIdx < NumTokens; ++CurIdx) { 5271 if (!SM.isBeforeInTranslationUnit(getTokenLoc(CurIdx), 5272 macroRange.getBegin())) 5273 break; 5274 } 5275 5276 if (CurIdx == NumTokens) 5277 return CXChildVisit_Break; 5278 5279 for (; CurIdx < NumTokens; ++CurIdx) { 5280 SourceLocation tokLoc = getTokenLoc(CurIdx); 5281 if (!SM.isBeforeInTranslationUnit(tokLoc, macroRange.getEnd())) 5282 break; 5283 5284 setFunctionMacroTokenLoc(CurIdx, SM.getMacroArgExpandedLocation(tokLoc)); 5285 } 5286 5287 if (CurIdx == NumTokens) 5288 return CXChildVisit_Break; 5289 5290 return CXChildVisit_Continue; 5291 } 5292 5293private: 5294 SourceLocation getTokenLoc(unsigned tokI) { 5295 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]); 5296 } 5297 5298 void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) { 5299 // The third field is reserved and currently not used. Use it here 5300 // to mark macro arg expanded tokens with their expanded locations. 5301 Tokens[tokI].int_data[3] = loc.getRawEncoding(); 5302 } 5303}; 5304 5305} // end anonymous namespace 5306 5307static CXChildVisitResult 5308MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent, 5309 CXClientData client_data) { 5310 return static_cast<MarkMacroArgTokensVisitor*>(client_data)->visit(cursor, 5311 parent); 5312} 5313 5314namespace { 5315 struct clang_annotateTokens_Data { 5316 CXTranslationUnit TU; 5317 ASTUnit *CXXUnit; 5318 CXToken *Tokens; 5319 unsigned NumTokens; 5320 CXCursor *Cursors; 5321 }; 5322} 5323 5324static void annotatePreprocessorTokens(CXTranslationUnit TU, 5325 SourceRange RegionOfInterest, 5326 AnnotateTokensData &Annotated) { 5327 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 5328 5329 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 5330 std::pair<FileID, unsigned> BeginLocInfo 5331 = SourceMgr.getDecomposedLoc(RegionOfInterest.getBegin()); 5332 std::pair<FileID, unsigned> EndLocInfo 5333 = SourceMgr.getDecomposedLoc(RegionOfInterest.getEnd()); 5334 5335 if (BeginLocInfo.first != EndLocInfo.first) 5336 return; 5337 5338 StringRef Buffer; 5339 bool Invalid = false; 5340 Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid); 5341 if (Buffer.empty() || Invalid) 5342 return; 5343 5344 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 5345 CXXUnit->getASTContext().getLangOpts(), 5346 Buffer.begin(), Buffer.data() + BeginLocInfo.second, 5347 Buffer.end()); 5348 Lex.SetCommentRetentionState(true); 5349 5350 // Lex tokens in raw mode until we hit the end of the range, to avoid 5351 // entering #includes or expanding macros. 5352 while (true) { 5353 Token Tok; 5354 Lex.LexFromRawLexer(Tok); 5355 5356 reprocess: 5357 if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) { 5358 // We have found a preprocessing directive. Gobble it up so that we 5359 // don't see it while preprocessing these tokens later, but keep track 5360 // of all of the token locations inside this preprocessing directive so 5361 // that we can annotate them appropriately. 5362 // 5363 // FIXME: Some simple tests here could identify macro definitions and 5364 // #undefs, to provide specific cursor kinds for those. 5365 SmallVector<SourceLocation, 32> Locations; 5366 do { 5367 Locations.push_back(Tok.getLocation()); 5368 Lex.LexFromRawLexer(Tok); 5369 } while (!Tok.isAtStartOfLine() && !Tok.is(tok::eof)); 5370 5371 using namespace cxcursor; 5372 CXCursor Cursor 5373 = MakePreprocessingDirectiveCursor(SourceRange(Locations.front(), 5374 Locations.back()), 5375 TU); 5376 for (unsigned I = 0, N = Locations.size(); I != N; ++I) { 5377 Annotated[Locations[I].getRawEncoding()] = Cursor; 5378 } 5379 5380 if (Tok.isAtStartOfLine()) 5381 goto reprocess; 5382 5383 continue; 5384 } 5385 5386 if (Tok.is(tok::eof)) 5387 break; 5388 } 5389} 5390 5391// This gets run a separate thread to avoid stack blowout. 5392static void clang_annotateTokensImpl(void *UserData) { 5393 CXTranslationUnit TU = ((clang_annotateTokens_Data*)UserData)->TU; 5394 ASTUnit *CXXUnit = ((clang_annotateTokens_Data*)UserData)->CXXUnit; 5395 CXToken *Tokens = ((clang_annotateTokens_Data*)UserData)->Tokens; 5396 const unsigned NumTokens = ((clang_annotateTokens_Data*)UserData)->NumTokens; 5397 CXCursor *Cursors = ((clang_annotateTokens_Data*)UserData)->Cursors; 5398 5399 CIndexer *CXXIdx = (CIndexer*)TU->CIdx; 5400 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 5401 setThreadBackgroundPriority(); 5402 5403 // Determine the region of interest, which contains all of the tokens. 5404 SourceRange RegionOfInterest; 5405 RegionOfInterest.setBegin( 5406 cxloc::translateSourceLocation(clang_getTokenLocation(TU, Tokens[0]))); 5407 RegionOfInterest.setEnd( 5408 cxloc::translateSourceLocation(clang_getTokenLocation(TU, 5409 Tokens[NumTokens-1]))); 5410 5411 // A mapping from the source locations found when re-lexing or traversing the 5412 // region of interest to the corresponding cursors. 5413 AnnotateTokensData Annotated; 5414 5415 // Relex the tokens within the source range to look for preprocessing 5416 // directives. 5417 annotatePreprocessorTokens(TU, RegionOfInterest, Annotated); 5418 5419 if (CXXUnit->getPreprocessor().getPreprocessingRecord()) { 5420 // Search and mark tokens that are macro argument expansions. 5421 MarkMacroArgTokensVisitor Visitor(CXXUnit->getSourceManager(), 5422 Tokens, NumTokens); 5423 CursorVisitor MacroArgMarker(TU, 5424 MarkMacroArgTokensVisitorDelegate, &Visitor, 5425 /*VisitPreprocessorLast=*/true, 5426 /*VisitIncludedEntities=*/false, 5427 RegionOfInterest); 5428 MacroArgMarker.visitPreprocessedEntitiesInRegion(); 5429 } 5430 5431 // Annotate all of the source locations in the region of interest that map to 5432 // a specific cursor. 5433 AnnotateTokensWorker W(Annotated, Tokens, Cursors, NumTokens, 5434 TU, RegionOfInterest); 5435 5436 // FIXME: We use a ridiculous stack size here because the data-recursion 5437 // algorithm uses a large stack frame than the non-data recursive version, 5438 // and AnnotationTokensWorker currently transforms the data-recursion 5439 // algorithm back into a traditional recursion by explicitly calling 5440 // VisitChildren(). We will need to remove this explicit recursive call. 5441 W.AnnotateTokens(); 5442 5443 // If we ran into any entities that involve context-sensitive keywords, 5444 // take another pass through the tokens to mark them as such. 5445 if (W.hasContextSensitiveKeywords()) { 5446 for (unsigned I = 0; I != NumTokens; ++I) { 5447 if (clang_getTokenKind(Tokens[I]) != CXToken_Identifier) 5448 continue; 5449 5450 if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) { 5451 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 5452 if (ObjCPropertyDecl *Property 5453 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(Cursors[I]))) { 5454 if (Property->getPropertyAttributesAsWritten() != 0 && 5455 llvm::StringSwitch<bool>(II->getName()) 5456 .Case("readonly", true) 5457 .Case("assign", true) 5458 .Case("unsafe_unretained", true) 5459 .Case("readwrite", true) 5460 .Case("retain", true) 5461 .Case("copy", true) 5462 .Case("nonatomic", true) 5463 .Case("atomic", true) 5464 .Case("getter", true) 5465 .Case("setter", true) 5466 .Case("strong", true) 5467 .Case("weak", true) 5468 .Default(false)) 5469 Tokens[I].int_data[0] = CXToken_Keyword; 5470 } 5471 continue; 5472 } 5473 5474 if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl || 5475 Cursors[I].kind == CXCursor_ObjCClassMethodDecl) { 5476 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 5477 if (llvm::StringSwitch<bool>(II->getName()) 5478 .Case("in", true) 5479 .Case("out", true) 5480 .Case("inout", true) 5481 .Case("oneway", true) 5482 .Case("bycopy", true) 5483 .Case("byref", true) 5484 .Default(false)) 5485 Tokens[I].int_data[0] = CXToken_Keyword; 5486 continue; 5487 } 5488 5489 if (Cursors[I].kind == CXCursor_CXXFinalAttr || 5490 Cursors[I].kind == CXCursor_CXXOverrideAttr) { 5491 Tokens[I].int_data[0] = CXToken_Keyword; 5492 continue; 5493 } 5494 } 5495 } 5496} 5497 5498extern "C" { 5499 5500void clang_annotateTokens(CXTranslationUnit TU, 5501 CXToken *Tokens, unsigned NumTokens, 5502 CXCursor *Cursors) { 5503 5504 if (NumTokens == 0 || !Tokens || !Cursors) 5505 return; 5506 5507 // Any token we don't specifically annotate will have a NULL cursor. 5508 CXCursor C = clang_getNullCursor(); 5509 for (unsigned I = 0; I != NumTokens; ++I) 5510 Cursors[I] = C; 5511 5512 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 5513 if (!CXXUnit) 5514 return; 5515 5516 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 5517 5518 clang_annotateTokens_Data data = { TU, CXXUnit, Tokens, NumTokens, Cursors }; 5519 llvm::CrashRecoveryContext CRC; 5520 if (!RunSafely(CRC, clang_annotateTokensImpl, &data, 5521 GetSafetyThreadStackSize() * 2)) { 5522 fprintf(stderr, "libclang: crash detected while annotating tokens\n"); 5523 } 5524} 5525 5526} // end: extern "C" 5527 5528//===----------------------------------------------------------------------===// 5529// Operations for querying linkage of a cursor. 5530//===----------------------------------------------------------------------===// 5531 5532extern "C" { 5533CXLinkageKind clang_getCursorLinkage(CXCursor cursor) { 5534 if (!clang_isDeclaration(cursor.kind)) 5535 return CXLinkage_Invalid; 5536 5537 Decl *D = cxcursor::getCursorDecl(cursor); 5538 if (NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D)) 5539 switch (ND->getLinkage()) { 5540 case NoLinkage: return CXLinkage_NoLinkage; 5541 case InternalLinkage: return CXLinkage_Internal; 5542 case UniqueExternalLinkage: return CXLinkage_UniqueExternal; 5543 case ExternalLinkage: return CXLinkage_External; 5544 }; 5545 5546 return CXLinkage_Invalid; 5547} 5548} // end: extern "C" 5549 5550//===----------------------------------------------------------------------===// 5551// Operations for querying language of a cursor. 5552//===----------------------------------------------------------------------===// 5553 5554static CXLanguageKind getDeclLanguage(const Decl *D) { 5555 if (!D) 5556 return CXLanguage_C; 5557 5558 switch (D->getKind()) { 5559 default: 5560 break; 5561 case Decl::ImplicitParam: 5562 case Decl::ObjCAtDefsField: 5563 case Decl::ObjCCategory: 5564 case Decl::ObjCCategoryImpl: 5565 case Decl::ObjCCompatibleAlias: 5566 case Decl::ObjCImplementation: 5567 case Decl::ObjCInterface: 5568 case Decl::ObjCIvar: 5569 case Decl::ObjCMethod: 5570 case Decl::ObjCProperty: 5571 case Decl::ObjCPropertyImpl: 5572 case Decl::ObjCProtocol: 5573 return CXLanguage_ObjC; 5574 case Decl::CXXConstructor: 5575 case Decl::CXXConversion: 5576 case Decl::CXXDestructor: 5577 case Decl::CXXMethod: 5578 case Decl::CXXRecord: 5579 case Decl::ClassTemplate: 5580 case Decl::ClassTemplatePartialSpecialization: 5581 case Decl::ClassTemplateSpecialization: 5582 case Decl::Friend: 5583 case Decl::FriendTemplate: 5584 case Decl::FunctionTemplate: 5585 case Decl::LinkageSpec: 5586 case Decl::Namespace: 5587 case Decl::NamespaceAlias: 5588 case Decl::NonTypeTemplateParm: 5589 case Decl::StaticAssert: 5590 case Decl::TemplateTemplateParm: 5591 case Decl::TemplateTypeParm: 5592 case Decl::UnresolvedUsingTypename: 5593 case Decl::UnresolvedUsingValue: 5594 case Decl::Using: 5595 case Decl::UsingDirective: 5596 case Decl::UsingShadow: 5597 return CXLanguage_CPlusPlus; 5598 } 5599 5600 return CXLanguage_C; 5601} 5602 5603extern "C" { 5604 5605enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) { 5606 if (clang_isDeclaration(cursor.kind)) 5607 if (Decl *D = cxcursor::getCursorDecl(cursor)) { 5608 if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted()) 5609 return CXAvailability_Available; 5610 5611 switch (D->getAvailability()) { 5612 case AR_Available: 5613 case AR_NotYetIntroduced: 5614 return CXAvailability_Available; 5615 5616 case AR_Deprecated: 5617 return CXAvailability_Deprecated; 5618 5619 case AR_Unavailable: 5620 return CXAvailability_NotAvailable; 5621 } 5622 } 5623 5624 return CXAvailability_Available; 5625} 5626 5627static CXVersion convertVersion(VersionTuple In) { 5628 CXVersion Out = { -1, -1, -1 }; 5629 if (In.empty()) 5630 return Out; 5631 5632 Out.Major = In.getMajor(); 5633 5634 if (llvm::Optional<unsigned> Minor = In.getMinor()) 5635 Out.Minor = *Minor; 5636 else 5637 return Out; 5638 5639 if (llvm::Optional<unsigned> Subminor = In.getSubminor()) 5640 Out.Subminor = *Subminor; 5641 5642 return Out; 5643} 5644 5645int clang_getCursorPlatformAvailability(CXCursor cursor, 5646 int *always_deprecated, 5647 CXString *deprecated_message, 5648 int *always_unavailable, 5649 CXString *unavailable_message, 5650 CXPlatformAvailability *availability, 5651 int availability_size) { 5652 if (always_deprecated) 5653 *always_deprecated = 0; 5654 if (deprecated_message) 5655 *deprecated_message = cxstring::createCXString("", /*DupString=*/false); 5656 if (always_unavailable) 5657 *always_unavailable = 0; 5658 if (unavailable_message) 5659 *unavailable_message = cxstring::createCXString("", /*DupString=*/false); 5660 5661 if (!clang_isDeclaration(cursor.kind)) 5662 return 0; 5663 5664 Decl *D = cxcursor::getCursorDecl(cursor); 5665 if (!D) 5666 return 0; 5667 5668 int N = 0; 5669 for (Decl::attr_iterator A = D->attr_begin(), AEnd = D->attr_end(); A != AEnd; 5670 ++A) { 5671 if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(*A)) { 5672 if (always_deprecated) 5673 *always_deprecated = 1; 5674 if (deprecated_message) 5675 *deprecated_message = cxstring::createCXString(Deprecated->getMessage()); 5676 continue; 5677 } 5678 5679 if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(*A)) { 5680 if (always_unavailable) 5681 *always_unavailable = 1; 5682 if (unavailable_message) { 5683 *unavailable_message 5684 = cxstring::createCXString(Unavailable->getMessage()); 5685 } 5686 continue; 5687 } 5688 5689 if (AvailabilityAttr *Avail = dyn_cast<AvailabilityAttr>(*A)) { 5690 if (N < availability_size) { 5691 availability[N].Platform 5692 = cxstring::createCXString(Avail->getPlatform()->getName()); 5693 availability[N].Introduced = convertVersion(Avail->getIntroduced()); 5694 availability[N].Deprecated = convertVersion(Avail->getDeprecated()); 5695 availability[N].Obsoleted = convertVersion(Avail->getObsoleted()); 5696 availability[N].Unavailable = Avail->getUnavailable(); 5697 availability[N].Message = cxstring::createCXString(Avail->getMessage()); 5698 } 5699 ++N; 5700 } 5701 } 5702 5703 return N; 5704} 5705 5706void clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability) { 5707 clang_disposeString(availability->Platform); 5708 clang_disposeString(availability->Message); 5709} 5710 5711CXLanguageKind clang_getCursorLanguage(CXCursor cursor) { 5712 if (clang_isDeclaration(cursor.kind)) 5713 return getDeclLanguage(cxcursor::getCursorDecl(cursor)); 5714 5715 return CXLanguage_Invalid; 5716} 5717 5718 /// \brief If the given cursor is the "templated" declaration 5719 /// descibing a class or function template, return the class or 5720 /// function template. 5721static Decl *maybeGetTemplateCursor(Decl *D) { 5722 if (!D) 5723 return 0; 5724 5725 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 5726 if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate()) 5727 return FunTmpl; 5728 5729 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) 5730 if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate()) 5731 return ClassTmpl; 5732 5733 return D; 5734} 5735 5736CXCursor clang_getCursorSemanticParent(CXCursor cursor) { 5737 if (clang_isDeclaration(cursor.kind)) { 5738 if (Decl *D = getCursorDecl(cursor)) { 5739 DeclContext *DC = D->getDeclContext(); 5740 if (!DC) 5741 return clang_getNullCursor(); 5742 5743 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 5744 getCursorTU(cursor)); 5745 } 5746 } 5747 5748 if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) { 5749 if (Decl *D = getCursorDecl(cursor)) 5750 return MakeCXCursor(D, getCursorTU(cursor)); 5751 } 5752 5753 return clang_getNullCursor(); 5754} 5755 5756CXCursor clang_getCursorLexicalParent(CXCursor cursor) { 5757 if (clang_isDeclaration(cursor.kind)) { 5758 if (Decl *D = getCursorDecl(cursor)) { 5759 DeclContext *DC = D->getLexicalDeclContext(); 5760 if (!DC) 5761 return clang_getNullCursor(); 5762 5763 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 5764 getCursorTU(cursor)); 5765 } 5766 } 5767 5768 // FIXME: Note that we can't easily compute the lexical context of a 5769 // statement or expression, so we return nothing. 5770 return clang_getNullCursor(); 5771} 5772 5773CXFile clang_getIncludedFile(CXCursor cursor) { 5774 if (cursor.kind != CXCursor_InclusionDirective) 5775 return 0; 5776 5777 InclusionDirective *ID = getCursorInclusionDirective(cursor); 5778 return (void *)ID->getFile(); 5779} 5780 5781CXSourceRange clang_Cursor_getCommentRange(CXCursor C) { 5782 if (!clang_isDeclaration(C.kind)) 5783 return clang_getNullRange(); 5784 5785 const Decl *D = getCursorDecl(C); 5786 ASTContext &Context = getCursorContext(C); 5787 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 5788 if (!RC) 5789 return clang_getNullRange(); 5790 5791 return cxloc::translateSourceRange(Context, RC->getSourceRange()); 5792} 5793 5794CXString clang_Cursor_getRawCommentText(CXCursor C) { 5795 if (!clang_isDeclaration(C.kind)) 5796 return createCXString((const char *) NULL); 5797 5798 const Decl *D = getCursorDecl(C); 5799 ASTContext &Context = getCursorContext(C); 5800 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 5801 StringRef RawText = RC ? RC->getRawText(Context.getSourceManager()) : 5802 StringRef(); 5803 5804 // Don't duplicate the string because RawText points directly into source 5805 // code. 5806 return createCXString(RawText, false); 5807} 5808 5809CXString clang_Cursor_getBriefCommentText(CXCursor C) { 5810 if (!clang_isDeclaration(C.kind)) 5811 return createCXString((const char *) NULL); 5812 5813 const Decl *D = getCursorDecl(C); 5814 const ASTContext &Context = getCursorContext(C); 5815 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 5816 5817 if (RC) { 5818 StringRef BriefText = RC->getBriefText(Context); 5819 5820 // Don't duplicate the string because RawComment ensures that this memory 5821 // will not go away. 5822 return createCXString(BriefText, false); 5823 } 5824 5825 return createCXString((const char *) NULL); 5826} 5827 5828CXComment clang_Cursor_getParsedComment(CXCursor C) { 5829 if (!clang_isDeclaration(C.kind)) 5830 return cxcomment::createCXComment(NULL, NULL); 5831 5832 const Decl *D = getCursorDecl(C); 5833 const ASTContext &Context = getCursorContext(C); 5834 const comments::FullComment *FC = Context.getCommentForDecl(D, /*PP=*/ NULL); 5835 5836 return cxcomment::createCXComment(FC, getCursorTU(C)); 5837} 5838 5839CXModule clang_Cursor_getModule(CXCursor C) { 5840 if (C.kind == CXCursor_ModuleImportDecl) { 5841 if (ImportDecl *ImportD = dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) 5842 return ImportD->getImportedModule(); 5843 } 5844 5845 return 0; 5846} 5847 5848CXModule clang_Module_getParent(CXModule CXMod) { 5849 if (!CXMod) 5850 return 0; 5851 Module *Mod = static_cast<Module*>(CXMod); 5852 return Mod->Parent; 5853} 5854 5855CXString clang_Module_getName(CXModule CXMod) { 5856 if (!CXMod) 5857 return createCXString(""); 5858 Module *Mod = static_cast<Module*>(CXMod); 5859 return createCXString(Mod->Name); 5860} 5861 5862CXString clang_Module_getFullName(CXModule CXMod) { 5863 if (!CXMod) 5864 return createCXString(""); 5865 Module *Mod = static_cast<Module*>(CXMod); 5866 return createCXString(Mod->getFullModuleName()); 5867} 5868 5869unsigned clang_Module_getNumTopLevelHeaders(CXModule CXMod) { 5870 if (!CXMod) 5871 return 0; 5872 Module *Mod = static_cast<Module*>(CXMod); 5873 return Mod->TopHeaders.size(); 5874} 5875 5876CXFile clang_Module_getTopLevelHeader(CXModule CXMod, unsigned Index) { 5877 if (!CXMod) 5878 return 0; 5879 Module *Mod = static_cast<Module*>(CXMod); 5880 5881 if (Index < Mod->TopHeaders.size()) 5882 return const_cast<FileEntry *>(Mod->TopHeaders[Index]); 5883 5884 return 0; 5885} 5886 5887} // end: extern "C" 5888 5889//===----------------------------------------------------------------------===// 5890// C++ AST instrospection. 5891//===----------------------------------------------------------------------===// 5892 5893extern "C" { 5894unsigned clang_CXXMethod_isStatic(CXCursor C) { 5895 if (!clang_isDeclaration(C.kind)) 5896 return 0; 5897 5898 CXXMethodDecl *Method = 0; 5899 Decl *D = cxcursor::getCursorDecl(C); 5900 if (FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(D)) 5901 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl()); 5902 else 5903 Method = dyn_cast_or_null<CXXMethodDecl>(D); 5904 return (Method && Method->isStatic()) ? 1 : 0; 5905} 5906 5907unsigned clang_CXXMethod_isVirtual(CXCursor C) { 5908 if (!clang_isDeclaration(C.kind)) 5909 return 0; 5910 5911 CXXMethodDecl *Method = 0; 5912 Decl *D = cxcursor::getCursorDecl(C); 5913 if (FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(D)) 5914 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl()); 5915 else 5916 Method = dyn_cast_or_null<CXXMethodDecl>(D); 5917 return (Method && Method->isVirtual()) ? 1 : 0; 5918} 5919} // end: extern "C" 5920 5921//===----------------------------------------------------------------------===// 5922// Attribute introspection. 5923//===----------------------------------------------------------------------===// 5924 5925extern "C" { 5926CXType clang_getIBOutletCollectionType(CXCursor C) { 5927 if (C.kind != CXCursor_IBOutletCollectionAttr) 5928 return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C)); 5929 5930 IBOutletCollectionAttr *A = 5931 cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C)); 5932 5933 return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorTU(C)); 5934} 5935} // end: extern "C" 5936 5937//===----------------------------------------------------------------------===// 5938// Inspecting memory usage. 5939//===----------------------------------------------------------------------===// 5940 5941typedef std::vector<CXTUResourceUsageEntry> MemUsageEntries; 5942 5943static inline void createCXTUResourceUsageEntry(MemUsageEntries &entries, 5944 enum CXTUResourceUsageKind k, 5945 unsigned long amount) { 5946 CXTUResourceUsageEntry entry = { k, amount }; 5947 entries.push_back(entry); 5948} 5949 5950extern "C" { 5951 5952const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) { 5953 const char *str = ""; 5954 switch (kind) { 5955 case CXTUResourceUsage_AST: 5956 str = "ASTContext: expressions, declarations, and types"; 5957 break; 5958 case CXTUResourceUsage_Identifiers: 5959 str = "ASTContext: identifiers"; 5960 break; 5961 case CXTUResourceUsage_Selectors: 5962 str = "ASTContext: selectors"; 5963 break; 5964 case CXTUResourceUsage_GlobalCompletionResults: 5965 str = "Code completion: cached global results"; 5966 break; 5967 case CXTUResourceUsage_SourceManagerContentCache: 5968 str = "SourceManager: content cache allocator"; 5969 break; 5970 case CXTUResourceUsage_AST_SideTables: 5971 str = "ASTContext: side tables"; 5972 break; 5973 case CXTUResourceUsage_SourceManager_Membuffer_Malloc: 5974 str = "SourceManager: malloc'ed memory buffers"; 5975 break; 5976 case CXTUResourceUsage_SourceManager_Membuffer_MMap: 5977 str = "SourceManager: mmap'ed memory buffers"; 5978 break; 5979 case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc: 5980 str = "ExternalASTSource: malloc'ed memory buffers"; 5981 break; 5982 case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap: 5983 str = "ExternalASTSource: mmap'ed memory buffers"; 5984 break; 5985 case CXTUResourceUsage_Preprocessor: 5986 str = "Preprocessor: malloc'ed memory"; 5987 break; 5988 case CXTUResourceUsage_PreprocessingRecord: 5989 str = "Preprocessor: PreprocessingRecord"; 5990 break; 5991 case CXTUResourceUsage_SourceManager_DataStructures: 5992 str = "SourceManager: data structures and tables"; 5993 break; 5994 case CXTUResourceUsage_Preprocessor_HeaderSearch: 5995 str = "Preprocessor: header search tables"; 5996 break; 5997 } 5998 return str; 5999} 6000 6001CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU) { 6002 if (!TU) { 6003 CXTUResourceUsage usage = { (void*) 0, 0, 0 }; 6004 return usage; 6005 } 6006 6007 ASTUnit *astUnit = static_cast<ASTUnit*>(TU->TUData); 6008 OwningPtr<MemUsageEntries> entries(new MemUsageEntries()); 6009 ASTContext &astContext = astUnit->getASTContext(); 6010 6011 // How much memory is used by AST nodes and types? 6012 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST, 6013 (unsigned long) astContext.getASTAllocatedMemory()); 6014 6015 // How much memory is used by identifiers? 6016 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Identifiers, 6017 (unsigned long) astContext.Idents.getAllocator().getTotalMemory()); 6018 6019 // How much memory is used for selectors? 6020 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Selectors, 6021 (unsigned long) astContext.Selectors.getTotalMemory()); 6022 6023 // How much memory is used by ASTContext's side tables? 6024 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST_SideTables, 6025 (unsigned long) astContext.getSideTableAllocatedMemory()); 6026 6027 // How much memory is used for caching global code completion results? 6028 unsigned long completionBytes = 0; 6029 if (GlobalCodeCompletionAllocator *completionAllocator = 6030 astUnit->getCachedCompletionAllocator().getPtr()) { 6031 completionBytes = completionAllocator->getTotalMemory(); 6032 } 6033 createCXTUResourceUsageEntry(*entries, 6034 CXTUResourceUsage_GlobalCompletionResults, 6035 completionBytes); 6036 6037 // How much memory is being used by SourceManager's content cache? 6038 createCXTUResourceUsageEntry(*entries, 6039 CXTUResourceUsage_SourceManagerContentCache, 6040 (unsigned long) astContext.getSourceManager().getContentCacheSize()); 6041 6042 // How much memory is being used by the MemoryBuffer's in SourceManager? 6043 const SourceManager::MemoryBufferSizes &srcBufs = 6044 astUnit->getSourceManager().getMemoryBufferSizes(); 6045 6046 createCXTUResourceUsageEntry(*entries, 6047 CXTUResourceUsage_SourceManager_Membuffer_Malloc, 6048 (unsigned long) srcBufs.malloc_bytes); 6049 createCXTUResourceUsageEntry(*entries, 6050 CXTUResourceUsage_SourceManager_Membuffer_MMap, 6051 (unsigned long) srcBufs.mmap_bytes); 6052 createCXTUResourceUsageEntry(*entries, 6053 CXTUResourceUsage_SourceManager_DataStructures, 6054 (unsigned long) astContext.getSourceManager() 6055 .getDataStructureSizes()); 6056 6057 // How much memory is being used by the ExternalASTSource? 6058 if (ExternalASTSource *esrc = astContext.getExternalSource()) { 6059 const ExternalASTSource::MemoryBufferSizes &sizes = 6060 esrc->getMemoryBufferSizes(); 6061 6062 createCXTUResourceUsageEntry(*entries, 6063 CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc, 6064 (unsigned long) sizes.malloc_bytes); 6065 createCXTUResourceUsageEntry(*entries, 6066 CXTUResourceUsage_ExternalASTSource_Membuffer_MMap, 6067 (unsigned long) sizes.mmap_bytes); 6068 } 6069 6070 // How much memory is being used by the Preprocessor? 6071 Preprocessor &pp = astUnit->getPreprocessor(); 6072 createCXTUResourceUsageEntry(*entries, 6073 CXTUResourceUsage_Preprocessor, 6074 pp.getTotalMemory()); 6075 6076 if (PreprocessingRecord *pRec = pp.getPreprocessingRecord()) { 6077 createCXTUResourceUsageEntry(*entries, 6078 CXTUResourceUsage_PreprocessingRecord, 6079 pRec->getTotalMemory()); 6080 } 6081 6082 createCXTUResourceUsageEntry(*entries, 6083 CXTUResourceUsage_Preprocessor_HeaderSearch, 6084 pp.getHeaderSearchInfo().getTotalMemory()); 6085 6086 CXTUResourceUsage usage = { (void*) entries.get(), 6087 (unsigned) entries->size(), 6088 entries->size() ? &(*entries)[0] : 0 }; 6089 entries.take(); 6090 return usage; 6091} 6092 6093void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage) { 6094 if (usage.data) 6095 delete (MemUsageEntries*) usage.data; 6096} 6097 6098} // end extern "C" 6099 6100void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) { 6101 CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU); 6102 for (unsigned I = 0; I != Usage.numEntries; ++I) 6103 fprintf(stderr, " %s: %lu\n", 6104 clang_getTUResourceUsageName(Usage.entries[I].kind), 6105 Usage.entries[I].amount); 6106 6107 clang_disposeCXTUResourceUsage(Usage); 6108} 6109 6110//===----------------------------------------------------------------------===// 6111// Misc. utility functions. 6112//===----------------------------------------------------------------------===// 6113 6114/// Default to using an 8 MB stack size on "safety" threads. 6115static unsigned SafetyStackThreadSize = 8 << 20; 6116 6117namespace clang { 6118 6119bool RunSafely(llvm::CrashRecoveryContext &CRC, 6120 void (*Fn)(void*), void *UserData, 6121 unsigned Size) { 6122 if (!Size) 6123 Size = GetSafetyThreadStackSize(); 6124 if (Size) 6125 return CRC.RunSafelyOnThread(Fn, UserData, Size); 6126 return CRC.RunSafely(Fn, UserData); 6127} 6128 6129unsigned GetSafetyThreadStackSize() { 6130 return SafetyStackThreadSize; 6131} 6132 6133void SetSafetyThreadStackSize(unsigned Value) { 6134 SafetyStackThreadSize = Value; 6135} 6136 6137} 6138 6139void clang::setThreadBackgroundPriority() { 6140 if (getenv("LIBCLANG_BGPRIO_DISABLE")) 6141 return; 6142 6143 // FIXME: Move to llvm/Support and make it cross-platform. 6144#ifdef __APPLE__ 6145 setpriority(PRIO_DARWIN_THREAD, 0, PRIO_DARWIN_BG); 6146#endif 6147} 6148 6149void cxindex::printDiagsToStderr(ASTUnit *Unit) { 6150 if (!Unit) 6151 return; 6152 6153 for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(), 6154 DEnd = Unit->stored_diag_end(); 6155 D != DEnd; ++D) { 6156 CXStoredDiagnostic Diag(*D, Unit->getASTContext().getLangOpts()); 6157 CXString Msg = clang_formatDiagnostic(&Diag, 6158 clang_defaultDiagnosticDisplayOptions()); 6159 fprintf(stderr, "%s\n", clang_getCString(Msg)); 6160 clang_disposeString(Msg); 6161 } 6162#ifdef LLVM_ON_WIN32 6163 // On Windows, force a flush, since there may be multiple copies of 6164 // stderr and stdout in the file system, all with different buffers 6165 // but writing to the same device. 6166 fflush(stderr); 6167#endif 6168} 6169 6170extern "C" { 6171 6172CXString clang_getClangVersion() { 6173 return createCXString(getClangFullVersion()); 6174} 6175 6176} // end: extern "C" 6177 6178