clang/tools/libclang/CIndex.cpp

   1 //===- CIndex.cpp - Clang-C Source Indexing Library -----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the main API hooks in the Clang-C Source Indexing
  11 // library.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "CIndexer.h"
  16 #include "CIndexDiagnostic.h"
  17 #include "CLog.h"
  18 #include "CXCursor.h"
  19 #include "CXSourceLocation.h"
  20 #include "CXString.h"
  21 #include "CXTranslationUnit.h"
  22 #include "CXType.h"
  23 #include "CursorVisitor.h"
  24 #include "clang/AST/Attr.h"
  25 #include "clang/AST/Mangle.h"
  26 #include "clang/AST/StmtVisitor.h"
  27 #include "clang/Basic/Diagnostic.h"
  28 #include "clang/Basic/DiagnosticCategories.h"
  29 #include "clang/Basic/DiagnosticIDs.h"
  30 #include "clang/Basic/TargetInfo.h"
  31 #include "clang/Basic/Version.h"
  32 #include "clang/Frontend/ASTUnit.h"
  33 #include "clang/Frontend/CompilerInstance.h"
  34 #include "clang/Frontend/FrontendDiagnostic.h"
  35 #include "clang/Index/CommentToXML.h"
  36 #include "clang/Lex/HeaderSearch.h"
  37 #include "clang/Lex/Lexer.h"
  38 #include "clang/Lex/PreprocessingRecord.h"
  39 #include "clang/Lex/Preprocessor.h"
  40 #include "clang/Serialization/SerializationDiagnostic.h"
  41 #include "llvm/ADT/Optional.h"
  42 #include "llvm/ADT/STLExtras.h"
  43 #include "llvm/ADT/StringSwitch.h"
  44 #include "llvm/Config/llvm-config.h"
  45 #include "llvm/IR/DataLayout.h"
  46 #include "llvm/IR/Mangler.h"
  47 #include "llvm/Support/Compiler.h"
  48 #include "llvm/Support/CrashRecoveryContext.h"
  49 #include "llvm/Support/Format.h"
  50 #include "llvm/Support/ManagedStatic.h"
  51 #include "llvm/Support/MemoryBuffer.h"
  52 #include "llvm/Support/Mutex.h"
  53 #include "llvm/Support/Program.h"
  54 #include "llvm/Support/SaveAndRestore.h"
  55 #include "llvm/Support/Signals.h"
  56 #include "llvm/Support/TargetSelect.h"
  57 #include "llvm/Support/Threading.h"
  58 #include "llvm/Support/Timer.h"
  59 #include "llvm/Support/raw_ostream.h"
  60
  61 #if LLVM_ENABLE_THREADS != 0 && defined(__APPLE__)
  62 #define USE_DARWIN_THREADS
  63 #endif
  64
  65 #ifdef USE_DARWIN_THREADS
  66 #include <pthread.h>
  67 #endif
  68
  69 using namespace clang;
  70 using namespace clang::cxcursor;
  71 using namespace clang::cxtu;
  72 using namespace clang::cxindex;
  73
  74 CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx, ASTUnit *AU) {
  75   if (!AU)
  76     return nullptr;
  77   assert(CIdx);
  78   CXTranslationUnit D = new CXTranslationUnitImpl();
  79   D->CIdx = CIdx;
  80   D->TheASTUnit = AU;
  81   D->StringPool = new cxstring::CXStringPool();
  82   D->Diagnostics = nullptr;
  83   D->OverridenCursorsPool = createOverridenCXCursorsPool();
  84   D->CommentToXML = nullptr;
  85   return D;
  86 }
  87
  88 bool cxtu::isASTReadError(ASTUnit *AU) {
  89   for (ASTUnit::stored_diag_iterator D = AU->stored_diag_begin(),
  90                                      DEnd = AU->stored_diag_end();
  91        D != DEnd; ++D) {
  92     if (D->getLevel() >= DiagnosticsEngine::Error &&
  93         DiagnosticIDs::getCategoryNumberForDiag(D->getID()) ==
  94             diag::DiagCat_AST_Deserialization_Issue)
  95       return true;
  96   }
  97   return false;
  98 }
  99
 100 cxtu::CXTUOwner::~CXTUOwner() {
 101   if (TU)
 102     clang_disposeTranslationUnit(TU);
 103 }
 104
 105 /// \brief Compare two source ranges to determine their relative position in
 106 /// the translation unit.
 107 static RangeComparisonResult RangeCompare(SourceManager &SM,
 108                                           SourceRange R1,
 109                                           SourceRange R2) {
 110   assert(R1.isValid() && "First range is invalid?");
 111   assert(R2.isValid() && "Second range is invalid?");
 112   if (R1.getEnd() != R2.getBegin() &&
 113       SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin()))
 114     return RangeBefore;
 115   if (R2.getEnd() != R1.getBegin() &&
 116       SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin()))
 117     return RangeAfter;
 118   return RangeOverlap;
 119 }
 120
 121 /// \brief Determine if a source location falls within, before, or after a
 122 ///   a given source range.
 123 static RangeComparisonResult LocationCompare(SourceManager &SM,
 124                                              SourceLocation L, SourceRange R) {
 125   assert(R.isValid() && "First range is invalid?");
 126   assert(L.isValid() && "Second range is invalid?");
 127   if (L == R.getBegin() || L == R.getEnd())
 128     return RangeOverlap;
 129   if (SM.isBeforeInTranslationUnit(L, R.getBegin()))
 130     return RangeBefore;
 131   if (SM.isBeforeInTranslationUnit(R.getEnd(), L))
 132     return RangeAfter;
 133   return RangeOverlap;
 134 }
 135
 136 /// \brief Translate a Clang source range into a CIndex source range.
 137 ///
 138 /// Clang internally represents ranges where the end location points to the
 139 /// start of the token at the end. However, for external clients it is more
 140 /// useful to have a CXSourceRange be a proper half-open interval. This routine
 141 /// does the appropriate translation.
 142 CXSourceRange cxloc::translateSourceRange(const SourceManager &SM,
 143                                           const LangOptions &LangOpts,
 144                                           const CharSourceRange &R) {
 145   // We want the last character in this location, so we will adjust the
 146   // location accordingly.
 147   SourceLocation EndLoc = R.getEnd();
 148   if (EndLoc.isValid() && EndLoc.isMacroID() && !SM.isMacroArgExpansion(EndLoc))
 149     EndLoc = SM.getExpansionRange(EndLoc).second;
 150   if (R.isTokenRange() && EndLoc.isValid()) {
 151     unsigned Length = Lexer::MeasureTokenLength(SM.getSpellingLoc(EndLoc),
 152                                                 SM, LangOpts);
 153     EndLoc = EndLoc.getLocWithOffset(Length);
 154   }
 155
 156   CXSourceRange Result = {
 157     { &SM, &LangOpts },
 158     R.getBegin().getRawEncoding(),
 159     EndLoc.getRawEncoding()
 160   };
 161   return Result;
 162 }
 163
 164 //===----------------------------------------------------------------------===//
 165 // Cursor visitor.
 166 //===----------------------------------------------------------------------===//
 167
 168 static SourceRange getRawCursorExtent(CXCursor C);
 169 static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr);
 170
 171
 172 RangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) {
 173   return RangeCompare(AU->getSourceManager(), R, RegionOfInterest);
 174 }
 175
 176 /// \brief Visit the given cursor and, if requested by the visitor,
 177 /// its children.
 178 ///
 179 /// \param Cursor the cursor to visit.
 180 ///
 181 /// \param CheckedRegionOfInterest if true, then the caller already checked
 182 /// that this cursor is within the region of interest.
 183 ///
 184 /// \returns true if the visitation should be aborted, false if it
 185 /// should continue.
 186 bool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) {
 187   if (clang_isInvalid(Cursor.kind))
 188     return false;
 189
 190   if (clang_isDeclaration(Cursor.kind)) {
 191     const Decl *D = getCursorDecl(Cursor);
 192     if (!D) {
 193       assert(0 && "Invalid declaration cursor");
 194       return true; // abort.
 195     }
 196
 197     // Ignore implicit declarations, unless it's an objc method because
 198     // currently we should report implicit methods for properties when indexing.
 199     if (D->isImplicit() && !isa<ObjCMethodDecl>(D))
 200       return false;
 201   }
 202
 203   // If we have a range of interest, and this cursor doesn't intersect with it,
 204   // we're done.
 205   if (RegionOfInterest.isValid() && !CheckedRegionOfInterest) {
 206     SourceRange Range = getRawCursorExtent(Cursor);
 207     if (Range.isInvalid() || CompareRegionOfInterest(Range))
 208       return false;
 209   }
 210
 211   switch (Visitor(Cursor, Parent, ClientData)) {
 212   case CXChildVisit_Break:
 213     return true;
 214
 215   case CXChildVisit_Continue:
 216     return false;
 217
 218   case CXChildVisit_Recurse: {
 219     bool ret = VisitChildren(Cursor);
 220     if (PostChildrenVisitor)
 221       if (PostChildrenVisitor(Cursor, ClientData))
 222         return true;
 223     return ret;
 224   }
 225   }
 226
 227   llvm_unreachable("Invalid CXChildVisitResult!");
 228 }
 229
 230 static bool visitPreprocessedEntitiesInRange(SourceRange R,
 231                                              PreprocessingRecord &PPRec,
 232                                              CursorVisitor &Visitor) {
 233   SourceManager &SM = Visitor.getASTUnit()->getSourceManager();
 234   FileID FID;
 235
 236   if (!Visitor.shouldVisitIncludedEntities()) {
 237     // If the begin/end of the range lie in the same FileID, do the optimization
 238     // where we skip preprocessed entities that do not come from the same FileID.
 239     FID = SM.getFileID(SM.getFileLoc(R.getBegin()));
 240     if (FID != SM.getFileID(SM.getFileLoc(R.getEnd())))
 241       FID = FileID();
 242   }
 243
 244   const auto &Entities = PPRec.getPreprocessedEntitiesInRange(R);
 245   return Visitor.visitPreprocessedEntities(Entities.begin(), Entities.end(),
 246                                            PPRec, FID);
 247 }
 248
 249 bool CursorVisitor::visitFileRegion() {
 250   if (RegionOfInterest.isInvalid())
 251     return false;
 252
 253   ASTUnit *Unit = cxtu::getASTUnit(TU);
 254   SourceManager &SM = Unit->getSourceManager();
 255
 256   std::pair<FileID, unsigned>
 257     Begin = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getBegin())),
 258     End = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getEnd()));
 259
 260   if (End.first != Begin.first) {
 261     // If the end does not reside in the same file, try to recover by
 262     // picking the end of the file of begin location.
 263     End.first = Begin.first;
 264     End.second = SM.getFileIDSize(Begin.first);
 265   }
 266
 267   assert(Begin.first == End.first);
 268   if (Begin.second > End.second)
 269     return false;
 270
 271   FileID File = Begin.first;
 272   unsigned Offset = Begin.second;
 273   unsigned Length = End.second - Begin.second;
 274
 275   if (!VisitDeclsOnly && !VisitPreprocessorLast)
 276     if (visitPreprocessedEntitiesInRegion())
 277       return true; // visitation break.
 278
 279   if (visitDeclsFromFileRegion(File, Offset, Length))
 280     return true; // visitation break.
 281
 282   if (!VisitDeclsOnly && VisitPreprocessorLast)
 283     return visitPreprocessedEntitiesInRegion();
 284
 285   return false;
 286 }
 287
 288 static bool isInLexicalContext(Decl *D, DeclContext *DC) {
 289   if (!DC)
 290     return false;
 291
 292   for (DeclContext *DeclDC = D->getLexicalDeclContext();
 293          DeclDC; DeclDC = DeclDC->getLexicalParent()) {
 294     if (DeclDC == DC)
 295       return true;
 296   }
 297   return false;
 298 }
 299
 300 bool CursorVisitor::visitDeclsFromFileRegion(FileID File,
 301                                              unsigned Offset, unsigned Length) {
 302   ASTUnit *Unit = cxtu::getASTUnit(TU);
 303   SourceManager &SM = Unit->getSourceManager();
 304   SourceRange Range = RegionOfInterest;
 305
 306   SmallVector<Decl *, 16> Decls;
 307   Unit->findFileRegionDecls(File, Offset, Length, Decls);
 308
 309   // If we didn't find any file level decls for the file, try looking at the
 310   // file that it was included from.
 311   while (Decls.empty() || Decls.front()->isTopLevelDeclInObjCContainer()) {
 312     bool Invalid = false;
 313     const SrcMgr::SLocEntry &SLEntry = SM.getSLocEntry(File, &Invalid);
 314     if (Invalid)
 315       return false;
 316
 317     SourceLocation Outer;
 318     if (SLEntry.isFile())
 319       Outer = SLEntry.getFile().getIncludeLoc();
 320     else
 321       Outer = SLEntry.getExpansion().getExpansionLocStart();
 322     if (Outer.isInvalid())
 323       return false;
 324
 325     std::tie(File, Offset) = SM.getDecomposedExpansionLoc(Outer);
 326     Length = 0;
 327     Unit->findFileRegionDecls(File, Offset, Length, Decls);
 328   }
 329
 330   assert(!Decls.empty());
 331
 332   bool VisitedAtLeastOnce = false;
 333   DeclContext *CurDC = nullptr;
 334   SmallVectorImpl<Decl *>::iterator DIt = Decls.begin();
 335   for (SmallVectorImpl<Decl *>::iterator DE = Decls.end(); DIt != DE; ++DIt) {
 336     Decl *D = *DIt;
 337     if (D->getSourceRange().isInvalid())
 338       continue;
 339
 340     if (isInLexicalContext(D, CurDC))
 341       continue;
 342
 343     CurDC = dyn_cast<DeclContext>(D);
 344
 345     if (TagDecl *TD = dyn_cast<TagDecl>(D))
 346       if (!TD->isFreeStanding())
 347         continue;
 348
 349     RangeComparisonResult CompRes = RangeCompare(SM, D->getSourceRange(),Range);
 350     if (CompRes == RangeBefore)
 351       continue;
 352     if (CompRes == RangeAfter)
 353       break;
 354
 355     assert(CompRes == RangeOverlap);
 356     VisitedAtLeastOnce = true;
 357
 358     if (isa<ObjCContainerDecl>(D)) {
 359       FileDI_current = &DIt;
 360       FileDE_current = DE;
 361     } else {
 362       FileDI_current = nullptr;
 363     }
 364
 365     if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true))
 366       return true; // visitation break.
 367   }
 368
 369   if (VisitedAtLeastOnce)
 370     return false;
 371
 372   // No Decls overlapped with the range. Move up the lexical context until there
 373   // is a context that contains the range or we reach the translation unit
 374   // level.
 375   DeclContext *DC = DIt == Decls.begin() ? (*DIt)->getLexicalDeclContext()
 376                                          : (*(DIt-1))->getLexicalDeclContext();
 377
 378   while (DC && !DC->isTranslationUnit()) {
 379     Decl *D = cast<Decl>(DC);
 380     SourceRange CurDeclRange = D->getSourceRange();
 381     if (CurDeclRange.isInvalid())
 382       break;
 383
 384     if (RangeCompare(SM, CurDeclRange, Range) == RangeOverlap) {
 385       if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true))
 386         return true; // visitation break.
 387     }
 388
 389     DC = D->getLexicalDeclContext();
 390   }
 391
 392   return false;
 393 }
 394
 395 bool CursorVisitor::visitPreprocessedEntitiesInRegion() {
 396   if (!AU->getPreprocessor().getPreprocessingRecord())
 397     return false;
 398
 399   PreprocessingRecord &PPRec
 400     = *AU->getPreprocessor().getPreprocessingRecord();
 401   SourceManager &SM = AU->getSourceManager();
 402
 403   if (RegionOfInterest.isValid()) {
 404     SourceRange MappedRange = AU->mapRangeToPreamble(RegionOfInterest);
 405     SourceLocation B = MappedRange.getBegin();
 406     SourceLocation E = MappedRange.getEnd();
 407
 408     if (AU->isInPreambleFileID(B)) {
 409       if (SM.isLoadedSourceLocation(E))
 410         return visitPreprocessedEntitiesInRange(SourceRange(B, E),
 411                                                  PPRec, *this);
 412
 413       // Beginning of range lies in the preamble but it also extends beyond
 414       // it into the main file. Split the range into 2 parts, one covering
 415       // the preamble and another covering the main file. This allows subsequent
 416       // calls to visitPreprocessedEntitiesInRange to accept a source range that
 417       // lies in the same FileID, allowing it to skip preprocessed entities that
 418       // do not come from the same FileID.
 419       bool breaked =
 420         visitPreprocessedEntitiesInRange(
 421                                    SourceRange(B, AU->getEndOfPreambleFileID()),
 422                                           PPRec, *this);
 423       if (breaked) return true;
 424       return visitPreprocessedEntitiesInRange(
 425                                     SourceRange(AU->getStartOfMainFileID(), E),
 426                                         PPRec, *this);
 427     }
 428
 429     return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec, *this);
 430   }
 431
 432   bool OnlyLocalDecls
 433     = !AU->isMainFileAST() && AU->getOnlyLocalDecls();
 434
 435   if (OnlyLocalDecls)
 436     return visitPreprocessedEntities(PPRec.local_begin(), PPRec.local_end(),
 437                                      PPRec);
 438
 439   return visitPreprocessedEntities(PPRec.begin(), PPRec.end(), PPRec);
 440 }
 441
 442 template<typename InputIterator>
 443 bool CursorVisitor::visitPreprocessedEntities(InputIterator First,
 444                                               InputIterator Last,
 445                                               PreprocessingRecord &PPRec,
 446                                               FileID FID) {
 447   for (; First != Last; ++First) {
 448     if (!FID.isInvalid() && !PPRec.isEntityInFileID(First, FID))
 449       continue;
 450
 451     PreprocessedEntity *PPE = *First;
 452     if (!PPE)
 453       continue;
 454
 455     if (MacroExpansion *ME = dyn_cast<MacroExpansion>(PPE)) {
 456       if (Visit(MakeMacroExpansionCursor(ME, TU)))
 457         return true;
 458
 459       continue;
 460     }
 461
 462     if (MacroDefinitionRecord *MD = dyn_cast<MacroDefinitionRecord>(PPE)) {
 463       if (Visit(MakeMacroDefinitionCursor(MD, TU)))
 464         return true;
 465
 466       continue;
 467     }
 468
 469     if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) {
 470       if (Visit(MakeInclusionDirectiveCursor(ID, TU)))
 471         return true;
 472
 473       continue;
 474     }
 475   }
 476
 477   return false;
 478 }
 479
 480 /// \brief Visit the children of the given cursor.
 481 ///
 482 /// \returns true if the visitation should be aborted, false if it
 483 /// should continue.
 484 bool CursorVisitor::VisitChildren(CXCursor Cursor) {
 485   if (clang_isReference(Cursor.kind) &&
 486       Cursor.kind != CXCursor_CXXBaseSpecifier) {
 487     // By definition, references have no children.
 488     return false;
 489   }
 490
 491   // Set the Parent field to Cursor, then back to its old value once we're
 492   // done.
 493   SetParentRAII SetParent(Parent, StmtParent, Cursor);
 494
 495   if (clang_isDeclaration(Cursor.kind)) {
 496     Decl *D = const_cast<Decl *>(getCursorDecl(Cursor));
 497     if (!D)
 498       return false;
 499
 500     return VisitAttributes(D) || Visit(D);
 501   }
 502
 503   if (clang_isStatement(Cursor.kind)) {
 504     if (const Stmt *S = getCursorStmt(Cursor))
 505       return Visit(S);
 506
 507     return false;
 508   }
 509
 510   if (clang_isExpression(Cursor.kind)) {
 511     if (const Expr *E = getCursorExpr(Cursor))
 512       return Visit(E);
 513
 514     return false;
 515   }
 516
 517   if (clang_isTranslationUnit(Cursor.kind)) {
 518     CXTranslationUnit TU = getCursorTU(Cursor);
 519     ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 520
 521     int VisitOrder[2] = { VisitPreprocessorLast, !VisitPreprocessorLast };
 522     for (unsigned I = 0; I != 2; ++I) {
 523       if (VisitOrder[I]) {
 524         if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() &&
 525             RegionOfInterest.isInvalid()) {
 526           for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(),
 527                                         TLEnd = CXXUnit->top_level_end();
 528                TL != TLEnd; ++TL) {
 529             if (Visit(MakeCXCursor(*TL, TU, RegionOfInterest), true))
 530               return true;
 531           }
 532         } else if (VisitDeclContext(
 533                                 CXXUnit->getASTContext().getTranslationUnitDecl()))
 534           return true;
 535         continue;
 536       }
 537
 538       // Walk the preprocessing record.
 539       if (CXXUnit->getPreprocessor().getPreprocessingRecord())
 540         visitPreprocessedEntitiesInRegion();
 541     }
 542
 543     return false;
 544   }
 545
 546   if (Cursor.kind == CXCursor_CXXBaseSpecifier) {
 547     if (const CXXBaseSpecifier *Base = getCursorCXXBaseSpecifier(Cursor)) {
 548       if (TypeSourceInfo *BaseTSInfo = Base->getTypeSourceInfo()) {
 549         return Visit(BaseTSInfo->getTypeLoc());
 550       }
 551     }
 552   }
 553
 554   if (Cursor.kind == CXCursor_IBOutletCollectionAttr) {
 555     const IBOutletCollectionAttr *A =
 556       cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(Cursor));
 557     if (const ObjCObjectType *ObjT = A->getInterface()->getAs<ObjCObjectType>())
 558       return Visit(cxcursor::MakeCursorObjCClassRef(
 559           ObjT->getInterface(),
 560           A->getInterfaceLoc()->getTypeLoc().getLocStart(), TU));
 561   }
 562
 563   // If pointing inside a macro definition, check if the token is an identifier
 564   // that was ever defined as a macro. In such a case, create a "pseudo" macro
 565   // expansion cursor for that token.
 566   SourceLocation BeginLoc = RegionOfInterest.getBegin();
 567   if (Cursor.kind == CXCursor_MacroDefinition &&
 568       BeginLoc == RegionOfInterest.getEnd()) {
 569     SourceLocation Loc = AU->mapLocationToPreamble(BeginLoc);
 570     const MacroInfo *MI =
 571         getMacroInfo(cxcursor::getCursorMacroDefinition(Cursor), TU);
 572     if (MacroDefinitionRecord *MacroDef =
 573             checkForMacroInMacroDefinition(MI, Loc, TU))
 574       return Visit(cxcursor::MakeMacroExpansionCursor(MacroDef, BeginLoc, TU));
 575   }
 576
 577   // Nothing to visit at the moment.
 578   return false;
 579 }
 580
 581 bool CursorVisitor::VisitBlockDecl(BlockDecl *B) {
 582   if (TypeSourceInfo *TSInfo = B->getSignatureAsWritten())
 583     if (Visit(TSInfo->getTypeLoc()))
 584         return true;
 585
 586   if (Stmt *Body = B->getBody())
 587     return Visit(MakeCXCursor(Body, StmtParent, TU, RegionOfInterest));
 588
 589   return false;
 590 }
 591
 592 Optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) {
 593   if (RegionOfInterest.isValid()) {
 594     SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager());
 595     if (Range.isInvalid())
 596       return None;
 597
 598     switch (CompareRegionOfInterest(Range)) {
 599     case RangeBefore:
 600       // This declaration comes before the region of interest; skip it.
 601       return None;
 602
 603     case RangeAfter:
 604       // This declaration comes after the region of interest; we're done.
 605       return false;
 606
 607     case RangeOverlap:
 608       // This declaration overlaps the region of interest; visit it.
 609       break;
 610     }
 611   }
 612   return true;
 613 }
 614
 615 bool CursorVisitor::VisitDeclContext(DeclContext *DC) {
 616   DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end();
 617
 618   // FIXME: Eventually remove.  This part of a hack to support proper
 619   // iteration over all Decls contained lexically within an ObjC container.
 620   SaveAndRestore<DeclContext::decl_iterator*> DI_saved(DI_current, &I);
 621   SaveAndRestore<DeclContext::decl_iterator> DE_saved(DE_current, E);
 622
 623   for ( ; I != E; ++I) {
 624     Decl *D = *I;
 625     if (D->getLexicalDeclContext() != DC)
 626       continue;
 627     CXCursor Cursor = MakeCXCursor(D, TU, RegionOfInterest);
 628
 629     // Ignore synthesized ivars here, otherwise if we have something like:
 630     //   @synthesize prop = _prop;
 631     // and '_prop' is not declared, we will encounter a '_prop' ivar before
 632     // encountering the 'prop' synthesize declaration and we will think that
 633     // we passed the region-of-interest.
 634     if (ObjCIvarDecl *ivarD = dyn_cast<ObjCIvarDecl>(D)) {
 635       if (ivarD->getSynthesize())
 636         continue;
 637     }
 638
 639     // FIXME: ObjCClassRef/ObjCProtocolRef for forward class/protocol
 640     // declarations is a mismatch with the compiler semantics.
 641     if (Cursor.kind == CXCursor_ObjCInterfaceDecl) {
 642       ObjCInterfaceDecl *ID = cast<ObjCInterfaceDecl>(D);
 643       if (!ID->isThisDeclarationADefinition())
 644         Cursor = MakeCursorObjCClassRef(ID, ID->getLocation(), TU);
 645
 646     } else if (Cursor.kind == CXCursor_ObjCProtocolDecl) {
 647       ObjCProtocolDecl *PD = cast<ObjCProtocolDecl>(D);
 648       if (!PD->isThisDeclarationADefinition())
 649         Cursor = MakeCursorObjCProtocolRef(PD, PD->getLocation(), TU);
 650     }
 651
 652     const Optional<bool> &V = shouldVisitCursor(Cursor);
 653     if (!V.hasValue())
 654       continue;
 655     if (!V.getValue())
 656       return false;
 657     if (Visit(Cursor, true))
 658       return true;
 659   }
 660   return false;
 661 }
 662
 663 bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
 664   llvm_unreachable("Translation units are visited directly by Visit()");
 665 }
 666
 667 bool CursorVisitor::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
 668     if (VisitTemplateParameters(D->getTemplateParameters()))
 669         return true;
 670
 671     return Visit(MakeCXCursor(D->getTemplatedDecl(), TU, RegionOfInterest));
 672 }
 673
 674 bool CursorVisitor::VisitTypeAliasDecl(TypeAliasDecl *D) {
 675   if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())
 676     return Visit(TSInfo->getTypeLoc());
 677
 678   return false;
 679 }
 680
 681 bool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) {
 682   if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())
 683     return Visit(TSInfo->getTypeLoc());
 684
 685   return false;
 686 }
 687
 688 bool CursorVisitor::VisitTagDecl(TagDecl *D) {
 689   return VisitDeclContext(D);
 690 }
 691
 692 bool CursorVisitor::VisitClassTemplateSpecializationDecl(
 693                                           ClassTemplateSpecializationDecl *D) {
 694   bool ShouldVisitBody = false;
 695   switch (D->getSpecializationKind()) {
 696   case TSK_Undeclared:
 697   case TSK_ImplicitInstantiation:
 698     // Nothing to visit
 699     return false;
 700
 701   case TSK_ExplicitInstantiationDeclaration:
 702   case TSK_ExplicitInstantiationDefinition:
 703     break;
 704
 705   case TSK_ExplicitSpecialization:
 706     ShouldVisitBody = true;
 707     break;
 708   }
 709
 710   // Visit the template arguments used in the specialization.
 711   if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) {
 712     TypeLoc TL = SpecType->getTypeLoc();
 713     if (TemplateSpecializationTypeLoc TSTLoc =
 714             TL.getAs<TemplateSpecializationTypeLoc>()) {
 715       for (unsigned I = 0, N = TSTLoc.getNumArgs(); I != N; ++I)
 716         if (VisitTemplateArgumentLoc(TSTLoc.getArgLoc(I)))
 717           return true;
 718     }
 719   }
 720
 721   if (ShouldVisitBody && VisitCXXRecordDecl(D))
 722     return true;
 723
 724   return false;
 725 }
 726
 727 bool CursorVisitor::VisitClassTemplatePartialSpecializationDecl(
 728                                    ClassTemplatePartialSpecializationDecl *D) {
 729   // FIXME: Visit the "outer" template parameter lists on the TagDecl
 730   // before visiting these template parameters.
 731   if (VisitTemplateParameters(D->getTemplateParameters()))
 732     return true;
 733
 734   // Visit the partial specialization arguments.
 735   const ASTTemplateArgumentListInfo *Info = D->getTemplateArgsAsWritten();
 736   const TemplateArgumentLoc *TemplateArgs = Info->getTemplateArgs();
 737   for (unsigned I = 0, N = Info->NumTemplateArgs; I != N; ++I)
 738     if (VisitTemplateArgumentLoc(TemplateArgs[I]))
 739       return true;
 740
 741   return VisitCXXRecordDecl(D);
 742 }
 743
 744 bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
 745   // Visit the default argument.
 746   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
 747     if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo())
 748       if (Visit(DefArg->getTypeLoc()))
 749         return true;
 750
 751   return false;
 752 }
 753
 754 bool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) {
 755   if (Expr *Init = D->getInitExpr())
 756     return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));
 757   return false;
 758 }
 759
 760 bool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) {
 761   unsigned NumParamList = DD->getNumTemplateParameterLists();
 762   for (unsigned i = 0; i < NumParamList; i++) {
 763     TemplateParameterList* Params = DD->getTemplateParameterList(i);
 764     if (VisitTemplateParameters(Params))
 765       return true;
 766   }
 767
 768   if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo())
 769     if (Visit(TSInfo->getTypeLoc()))
 770       return true;
 771
 772   // Visit the nested-name-specifier, if present.
 773   if (NestedNameSpecifierLoc QualifierLoc = DD->getQualifierLoc())
 774     if (VisitNestedNameSpecifierLoc(QualifierLoc))
 775       return true;
 776
 777   return false;
 778 }
 779
 780 /// \brief Compare two base or member initializers based on their source order.
 781 static int CompareCXXCtorInitializers(CXXCtorInitializer *const *X,
 782                                       CXXCtorInitializer *const *Y) {
 783   return (*X)->getSourceOrder() - (*Y)->getSourceOrder();
 784 }
 785
 786 bool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) {
 787   unsigned NumParamList = ND->getNumTemplateParameterLists();
 788   for (unsigned i = 0; i < NumParamList; i++) {
 789     TemplateParameterList* Params = ND->getTemplateParameterList(i);
 790     if (VisitTemplateParameters(Params))
 791       return true;
 792   }
 793
 794   if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) {
 795     // Visit the function declaration's syntactic components in the order
 796     // written. This requires a bit of work.
 797     TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens();
 798     FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>();
 799
 800     // If we have a function declared directly (without the use of a typedef),
 801     // visit just the return type. Otherwise, just visit the function's type
 802     // now.
 803     if ((FTL && !isa<CXXConversionDecl>(ND) && Visit(FTL.getReturnLoc())) ||
 804         (!FTL && Visit(TL)))
 805       return true;
 806
 807     // Visit the nested-name-specifier, if present.
 808     if (NestedNameSpecifierLoc QualifierLoc = ND->getQualifierLoc())
 809       if (VisitNestedNameSpecifierLoc(QualifierLoc))
 810         return true;
 811
 812     // Visit the declaration name.
 813     if (!isa<CXXDestructorDecl>(ND))
 814       if (VisitDeclarationNameInfo(ND->getNameInfo()))
 815         return true;
 816
 817     // FIXME: Visit explicitly-specified template arguments!
 818
 819     // Visit the function parameters, if we have a function type.
 820     if (FTL && VisitFunctionTypeLoc(FTL, true))
 821       return true;
 822
 823     // FIXME: Attributes?
 824   }
 825
 826   if (ND->doesThisDeclarationHaveABody() && !ND->isLateTemplateParsed()) {
 827     if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) {
 828       // Find the initializers that were written in the source.
 829       SmallVector<CXXCtorInitializer *, 4> WrittenInits;
 830       for (auto *I : Constructor->inits()) {
 831         if (!I->isWritten())
 832           continue;
 833
 834         WrittenInits.push_back(I);
 835       }
 836
 837       // Sort the initializers in source order
 838       llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(),
 839                            &CompareCXXCtorInitializers);
 840
 841       // Visit the initializers in source order
 842       for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) {
 843         CXXCtorInitializer *Init = WrittenInits[I];
 844         if (Init->isAnyMemberInitializer()) {
 845           if (Visit(MakeCursorMemberRef(Init->getAnyMember(),
 846                                         Init->getMemberLocation(), TU)))
 847             return true;
 848         } else if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) {
 849           if (Visit(TInfo->getTypeLoc()))
 850             return true;
 851         }
 852
 853         // Visit the initializer value.
 854         if (Expr *Initializer = Init->getInit())
 855           if (Visit(MakeCXCursor(Initializer, ND, TU, RegionOfInterest)))
 856             return true;
 857       }
 858     }
 859
 860     if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest)))
 861       return true;
 862   }
 863
 864   return false;
 865 }
 866
 867 bool CursorVisitor::VisitFieldDecl(FieldDecl *D) {
 868   if (VisitDeclaratorDecl(D))
 869     return true;
 870
 871   if (Expr *BitWidth = D->getBitWidth())
 872     return Visit(MakeCXCursor(BitWidth, StmtParent, TU, RegionOfInterest));
 873
 874   return false;
 875 }
 876
 877 bool CursorVisitor::VisitVarDecl(VarDecl *D) {
 878   if (VisitDeclaratorDecl(D))
 879     return true;
 880
 881   if (Expr *Init = D->getInit())
 882     return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest));
 883
 884   return false;
 885 }
 886
 887 bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
 888   if (VisitDeclaratorDecl(D))
 889     return true;
 890
 891   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
 892     if (Expr *DefArg = D->getDefaultArgument())
 893       return Visit(MakeCXCursor(DefArg, StmtParent, TU, RegionOfInterest));
 894
 895   return false;
 896 }
 897
 898 bool CursorVisitor::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
 899   // FIXME: Visit the "outer" template parameter lists on the FunctionDecl
 900   // before visiting these template parameters.
 901   if (VisitTemplateParameters(D->getTemplateParameters()))
 902     return true;
 903
 904   return VisitFunctionDecl(D->getTemplatedDecl());
 905 }
 906
 907 bool CursorVisitor::VisitClassTemplateDecl(ClassTemplateDecl *D) {
 908   // FIXME: Visit the "outer" template parameter lists on the TagDecl
 909   // before visiting these template parameters.
 910   if (VisitTemplateParameters(D->getTemplateParameters()))
 911     return true;
 912
 913   return VisitCXXRecordDecl(D->getTemplatedDecl());
 914 }
 915
 916 bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
 917   if (VisitTemplateParameters(D->getTemplateParameters()))
 918     return true;
 919
 920   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() &&
 921       VisitTemplateArgumentLoc(D->getDefaultArgument()))
 922     return true;
 923
 924   return false;
 925 }
 926
 927 bool CursorVisitor::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
 928   // Visit the bound, if it's explicit.
 929   if (D->hasExplicitBound()) {
 930     if (auto TInfo = D->getTypeSourceInfo()) {
 931       if (Visit(TInfo->getTypeLoc()))
 932         return true;
 933     }
 934   }
 935
 936   return false;
 937 }
 938
 939 bool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) {
 940   if (TypeSourceInfo *TSInfo = ND->getReturnTypeSourceInfo())
 941     if (Visit(TSInfo->getTypeLoc()))
 942       return true;
 943
 944   for (const auto *P : ND->params()) {
 945     if (Visit(MakeCXCursor(P, TU, RegionOfInterest)))
 946       return true;
 947   }
 948
 949   if (ND->isThisDeclarationADefinition() &&
 950       Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest)))
 951     return true;
 952
 953   return false;
 954 }
 955
 956 template <typename DeclIt>
 957 static void addRangedDeclsInContainer(DeclIt *DI_current, DeclIt DE_current,
 958                                       SourceManager &SM, SourceLocation EndLoc,
 959                                       SmallVectorImpl<Decl *> &Decls) {
 960   DeclIt next = *DI_current;
 961   while (++next != DE_current) {
 962     Decl *D_next = *next;
 963     if (!D_next)
 964       break;
 965     SourceLocation L = D_next->getLocStart();
 966     if (!L.isValid())
 967       break;
 968     if (SM.isBeforeInTranslationUnit(L, EndLoc)) {
 969       *DI_current = next;
 970       Decls.push_back(D_next);
 971       continue;
 972     }
 973     break;
 974   }
 975 }
 976
 977 bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) {
 978   // FIXME: Eventually convert back to just 'VisitDeclContext()'.  Essentially
 979   // an @implementation can lexically contain Decls that are not properly
 980   // nested in the AST.  When we identify such cases, we need to retrofit
 981   // this nesting here.
 982   if (!DI_current && !FileDI_current)
 983     return VisitDeclContext(D);
 984
 985   // Scan the Decls that immediately come after the container
 986   // in the current DeclContext.  If any fall within the
 987   // container's lexical region, stash them into a vector
 988   // for later processing.
 989   SmallVector<Decl *, 24> DeclsInContainer;
 990   SourceLocation EndLoc = D->getSourceRange().getEnd();
 991   SourceManager &SM = AU->getSourceManager();
 992   if (EndLoc.isValid()) {
 993     if (DI_current) {
 994       addRangedDeclsInContainer(DI_current, DE_current, SM, EndLoc,
 995                                 DeclsInContainer);
 996     } else {
 997       addRangedDeclsInContainer(FileDI_current, FileDE_current, SM, EndLoc,
 998                                 DeclsInContainer);
 999     }
1000   }
1001
1002   // The common case.
1003   if (DeclsInContainer.empty())
1004     return VisitDeclContext(D);
1005
1006   // Get all the Decls in the DeclContext, and sort them with the
1007   // additional ones we've collected.  Then visit them.
1008   for (auto *SubDecl : D->decls()) {
1009     if (!SubDecl || SubDecl->getLexicalDeclContext() != D ||
1010         SubDecl->getLocStart().isInvalid())
1011       continue;
1012     DeclsInContainer.push_back(SubDecl);
1013   }
1014
1015   // Now sort the Decls so that they appear in lexical order.
1016   std::sort(DeclsInContainer.begin(), DeclsInContainer.end(),
1017             [&SM](Decl *A, Decl *B) {
1018     SourceLocation L_A = A->getLocStart();
1019     SourceLocation L_B = B->getLocStart();
1020     assert(L_A.isValid() && L_B.isValid());
1021     return SM.isBeforeInTranslationUnit(L_A, L_B);
1022   });
1023
1024   // Now visit the decls.
1025   for (SmallVectorImpl<Decl*>::iterator I = DeclsInContainer.begin(),
1026          E = DeclsInContainer.end(); I != E; ++I) {
1027     CXCursor Cursor = MakeCXCursor(*I, TU, RegionOfInterest);
1028     const Optional<bool> &V = shouldVisitCursor(Cursor);
1029     if (!V.hasValue())
1030       continue;
1031     if (!V.getValue())
1032       return false;
1033     if (Visit(Cursor, true))
1034       return true;
1035   }
1036   return false;
1037 }
1038
1039 bool CursorVisitor::VisitObjCCategoryDecl(ObjCCategoryDecl *ND) {
1040   if (Visit(MakeCursorObjCClassRef(ND->getClassInterface(), ND->getLocation(),
1041                                    TU)))
1042     return true;
1043
1044   if (VisitObjCTypeParamList(ND->getTypeParamList()))
1045     return true;
1046
1047   ObjCCategoryDecl::protocol_loc_iterator PL = ND->protocol_loc_begin();
1048   for (ObjCCategoryDecl::protocol_iterator I = ND->protocol_begin(),
1049          E = ND->protocol_end(); I != E; ++I, ++PL)
1050     if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1051       return true;
1052
1053   return VisitObjCContainerDecl(ND);
1054 }
1055
1056 bool CursorVisitor::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) {
1057   if (!PID->isThisDeclarationADefinition())
1058     return Visit(MakeCursorObjCProtocolRef(PID, PID->getLocation(), TU));
1059
1060   ObjCProtocolDecl::protocol_loc_iterator PL = PID->protocol_loc_begin();
1061   for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(),
1062        E = PID->protocol_end(); I != E; ++I, ++PL)
1063     if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1064       return true;
1065
1066   return VisitObjCContainerDecl(PID);
1067 }
1068
1069 bool CursorVisitor::VisitObjCPropertyDecl(ObjCPropertyDecl *PD) {
1070   if (PD->getTypeSourceInfo() && Visit(PD->getTypeSourceInfo()->getTypeLoc()))
1071     return true;
1072
1073   // FIXME: This implements a workaround with @property declarations also being
1074   // installed in the DeclContext for the @interface.  Eventually this code
1075   // should be removed.
1076   ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(PD->getDeclContext());
1077   if (!CDecl || !CDecl->IsClassExtension())
1078     return false;
1079
1080   ObjCInterfaceDecl *ID = CDecl->getClassInterface();
1081   if (!ID)
1082     return false;
1083
1084   IdentifierInfo *PropertyId = PD->getIdentifier();
1085   ObjCPropertyDecl *prevDecl =
1086     ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(ID), PropertyId);
1087
1088   if (!prevDecl)
1089     return false;
1090
1091   // Visit synthesized methods since they will be skipped when visiting
1092   // the @interface.
1093   if (ObjCMethodDecl *MD = prevDecl->getGetterMethodDecl())
1094     if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl)
1095       if (Visit(MakeCXCursor(MD, TU, RegionOfInterest)))
1096         return true;
1097
1098   if (ObjCMethodDecl *MD = prevDecl->getSetterMethodDecl())
1099     if (MD->isPropertyAccessor() && MD->getLexicalDeclContext() == CDecl)
1100       if (Visit(MakeCXCursor(MD, TU, RegionOfInterest)))
1101         return true;
1102
1103   return false;
1104 }
1105
1106 bool CursorVisitor::VisitObjCTypeParamList(ObjCTypeParamList *typeParamList) {
1107   if (!typeParamList)
1108     return false;
1109
1110   for (auto *typeParam : *typeParamList) {
1111     // Visit the type parameter.
1112     if (Visit(MakeCXCursor(typeParam, TU, RegionOfInterest)))
1113       return true;
1114   }
1115
1116   return false;
1117 }
1118
1119 bool CursorVisitor::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
1120   if (!D->isThisDeclarationADefinition()) {
1121     // Forward declaration is treated like a reference.
1122     return Visit(MakeCursorObjCClassRef(D, D->getLocation(), TU));
1123   }
1124
1125   // Objective-C type parameters.
1126   if (VisitObjCTypeParamList(D->getTypeParamListAsWritten()))
1127     return true;
1128
1129   // Issue callbacks for super class.
1130   if (D->getSuperClass() &&
1131       Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(),
1132                                         D->getSuperClassLoc(),
1133                                         TU)))
1134     return true;
1135
1136   if (TypeSourceInfo *SuperClassTInfo = D->getSuperClassTInfo())
1137     if (Visit(SuperClassTInfo->getTypeLoc()))
1138       return true;
1139
1140   ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin();
1141   for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(),
1142          E = D->protocol_end(); I != E; ++I, ++PL)
1143     if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
1144       return true;
1145
1146   return VisitObjCContainerDecl(D);
1147 }
1148
1149 bool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) {
1150   return VisitObjCContainerDecl(D);
1151 }
1152
1153 bool CursorVisitor::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
1154   // 'ID' could be null when dealing with invalid code.
1155   if (ObjCInterfaceDecl *ID = D->getClassInterface())
1156     if (Visit(MakeCursorObjCClassRef(ID, D->getLocation(), TU)))
1157       return true;
1158
1159   return VisitObjCImplDecl(D);
1160 }
1161
1162 bool CursorVisitor::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
1163 #if 0
1164   // Issue callbacks for super class.
1165   // FIXME: No source location information!
1166   if (D->getSuperClass() &&
1167       Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(),
1168                                         D->getSuperClassLoc(),
1169                                         TU)))
1170     return true;
1171 #endif
1172
1173   return VisitObjCImplDecl(D);
1174 }
1175
1176 bool CursorVisitor::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD) {
1177   if (ObjCIvarDecl *Ivar = PD->getPropertyIvarDecl())
1178     if (PD->isIvarNameSpecified())
1179       return Visit(MakeCursorMemberRef(Ivar, PD->getPropertyIvarDeclLoc(), TU));
1180
1181   return false;
1182 }
1183
1184 bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) {
1185   return VisitDeclContext(D);
1186 }
1187
1188 bool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1189   // Visit nested-name-specifier.
1190   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1191     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1192       return true;
1193
1194   return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(),
1195                                       D->getTargetNameLoc(), TU));
1196 }
1197
1198 bool CursorVisitor::VisitUsingDecl(UsingDecl *D) {
1199   // Visit nested-name-specifier.
1200   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
1201     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1202       return true;
1203   }
1204
1205   if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU)))
1206     return true;
1207
1208   return VisitDeclarationNameInfo(D->getNameInfo());
1209 }
1210
1211 bool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1212   // Visit nested-name-specifier.
1213   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1214     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1215       return true;
1216
1217   return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(),
1218                                       D->getIdentLocation(), TU));
1219 }
1220
1221 bool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1222   // Visit nested-name-specifier.
1223   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
1224     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1225       return true;
1226   }
1227
1228   return VisitDeclarationNameInfo(D->getNameInfo());
1229 }
1230
1231 bool CursorVisitor::VisitUnresolvedUsingTypenameDecl(
1232                                                UnresolvedUsingTypenameDecl *D) {
1233   // Visit nested-name-specifier.
1234   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1235     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1236       return true;
1237
1238   return false;
1239 }
1240
1241 bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) {
1242   switch (Name.getName().getNameKind()) {
1243   case clang::DeclarationName::Identifier:
1244   case clang::DeclarationName::CXXLiteralOperatorName:
1245   case clang::DeclarationName::CXXOperatorName:
1246   case clang::DeclarationName::CXXUsingDirective:
1247     return false;
1248
1249   case clang::DeclarationName::CXXConstructorName:
1250   case clang::DeclarationName::CXXDestructorName:
1251   case clang::DeclarationName::CXXConversionFunctionName:
1252     if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo())
1253       return Visit(TSInfo->getTypeLoc());
1254     return false;
1255
1256   case clang::DeclarationName::ObjCZeroArgSelector:
1257   case clang::DeclarationName::ObjCOneArgSelector:
1258   case clang::DeclarationName::ObjCMultiArgSelector:
1259     // FIXME: Per-identifier location info?
1260     return false;
1261   }
1262
1263   llvm_unreachable("Invalid DeclarationName::Kind!");
1264 }
1265
1266 bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS,
1267                                              SourceRange Range) {
1268   // FIXME: This whole routine is a hack to work around the lack of proper
1269   // source information in nested-name-specifiers (PR5791). Since we do have
1270   // a beginning source location, we can visit the first component of the
1271   // nested-name-specifier, if it's a single-token component.
1272   if (!NNS)
1273     return false;
1274
1275   // Get the first component in the nested-name-specifier.
1276   while (NestedNameSpecifier *Prefix = NNS->getPrefix())
1277     NNS = Prefix;
1278
1279   switch (NNS->getKind()) {
1280   case NestedNameSpecifier::Namespace:
1281     return Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(),
1282                                         TU));
1283
1284   case NestedNameSpecifier::NamespaceAlias:
1285     return Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(),
1286                                         Range.getBegin(), TU));
1287
1288   case NestedNameSpecifier::TypeSpec: {
1289     // If the type has a form where we know that the beginning of the source
1290     // range matches up with a reference cursor. Visit the appropriate reference
1291     // cursor.
1292     const Type *T = NNS->getAsType();
1293     if (const TypedefType *Typedef = dyn_cast<TypedefType>(T))
1294       return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU));
1295     if (const TagType *Tag = dyn_cast<TagType>(T))
1296       return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU));
1297     if (const TemplateSpecializationType *TST
1298                                       = dyn_cast<TemplateSpecializationType>(T))
1299       return VisitTemplateName(TST->getTemplateName(), Range.getBegin());
1300     break;
1301   }
1302
1303   case NestedNameSpecifier::TypeSpecWithTemplate:
1304   case NestedNameSpecifier::Global:
1305   case NestedNameSpecifier::Identifier:
1306   case NestedNameSpecifier::Super:
1307     break;
1308   }
1309
1310   return false;
1311 }
1312
1313 bool
1314 CursorVisitor::VisitNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) {
1315   SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
1316   for (; Qualifier; Qualifier = Qualifier.getPrefix())
1317     Qualifiers.push_back(Qualifier);
1318
1319   while (!Qualifiers.empty()) {
1320     NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
1321     NestedNameSpecifier *NNS = Q.getNestedNameSpecifier();
1322     switch (NNS->getKind()) {
1323     case NestedNameSpecifier::Namespace:
1324       if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(),
1325                                        Q.getLocalBeginLoc(),
1326                                        TU)))
1327         return true;
1328
1329       break;
1330
1331     case NestedNameSpecifier::NamespaceAlias:
1332       if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(),
1333                                        Q.getLocalBeginLoc(),
1334                                        TU)))
1335         return true;
1336
1337       break;
1338
1339     case NestedNameSpecifier::TypeSpec:
1340     case NestedNameSpecifier::TypeSpecWithTemplate:
1341       if (Visit(Q.getTypeLoc()))
1342         return true;
1343
1344       break;
1345
1346     case NestedNameSpecifier::Global:
1347     case NestedNameSpecifier::Identifier:
1348     case NestedNameSpecifier::Super:
1349       break;
1350     }
1351   }
1352
1353   return false;
1354 }
1355
1356 bool CursorVisitor::VisitTemplateParameters(
1357                                           const TemplateParameterList *Params) {
1358   if (!Params)
1359     return false;
1360
1361   for (TemplateParameterList::const_iterator P = Params->begin(),
1362                                           PEnd = Params->end();
1363        P != PEnd; ++P) {
1364     if (Visit(MakeCXCursor(*P, TU, RegionOfInterest)))
1365       return true;
1366   }
1367
1368   return false;
1369 }
1370
1371 bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) {
1372   switch (Name.getKind()) {
1373   case TemplateName::Template:
1374     return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU));
1375
1376   case TemplateName::OverloadedTemplate:
1377     // Visit the overloaded template set.
1378     if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU)))
1379       return true;
1380
1381     return false;
1382
1383   case TemplateName::DependentTemplate:
1384     // FIXME: Visit nested-name-specifier.
1385     return false;
1386
1387   case TemplateName::QualifiedTemplate:
1388     // FIXME: Visit nested-name-specifier.
1389     return Visit(MakeCursorTemplateRef(
1390                                   Name.getAsQualifiedTemplateName()->getDecl(),
1391                                        Loc, TU));
1392
1393   case TemplateName::SubstTemplateTemplateParm:
1394     return Visit(MakeCursorTemplateRef(
1395                          Name.getAsSubstTemplateTemplateParm()->getParameter(),
1396                                        Loc, TU));
1397
1398   case TemplateName::SubstTemplateTemplateParmPack:
1399     return Visit(MakeCursorTemplateRef(
1400                   Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(),
1401                                        Loc, TU));
1402   }
1403
1404   llvm_unreachable("Invalid TemplateName::Kind!");
1405 }
1406
1407 bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) {
1408   switch (TAL.getArgument().getKind()) {
1409   case TemplateArgument::Null:
1410   case TemplateArgument::Integral:
1411   case TemplateArgument::Pack:
1412     return false;
1413
1414   case TemplateArgument::Type:
1415     if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo())
1416       return Visit(TSInfo->getTypeLoc());
1417     return false;
1418
1419   case TemplateArgument::Declaration:
1420     if (Expr *E = TAL.getSourceDeclExpression())
1421       return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1422     return false;
1423
1424   case TemplateArgument::NullPtr:
1425     if (Expr *E = TAL.getSourceNullPtrExpression())
1426       return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1427     return false;
1428
1429   case TemplateArgument::Expression:
1430     if (Expr *E = TAL.getSourceExpression())
1431       return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest));
1432     return false;
1433
1434   case TemplateArgument::Template:
1435   case TemplateArgument::TemplateExpansion:
1436     if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc()))
1437       return true;
1438
1439     return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(),
1440                              TAL.getTemplateNameLoc());
1441   }
1442
1443   llvm_unreachable("Invalid TemplateArgument::Kind!");
1444 }
1445
1446 bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1447   return VisitDeclContext(D);
1448 }
1449
1450 bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
1451   return Visit(TL.getUnqualifiedLoc());
1452 }
1453
1454 bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
1455   ASTContext &Context = AU->getASTContext();
1456
1457   // Some builtin types (such as Objective-C's "id", "sel", and
1458   // "Class") have associated declarations. Create cursors for those.
1459   QualType VisitType;
1460   switch (TL.getTypePtr()->getKind()) {
1461
1462   case BuiltinType::Void:
1463   case BuiltinType::NullPtr:
1464   case BuiltinType::Dependent:
1465   case BuiltinType::OCLImage1d:
1466   case BuiltinType::OCLImage1dArray:
1467   case BuiltinType::OCLImage1dBuffer:
1468   case BuiltinType::OCLImage2d:
1469   case BuiltinType::OCLImage2dArray:
1470   case BuiltinType::OCLImage2dDepth:
1471   case BuiltinType::OCLImage2dArrayDepth:
1472   case BuiltinType::OCLImage2dMSAA:
1473   case BuiltinType::OCLImage2dArrayMSAA:
1474   case BuiltinType::OCLImage2dMSAADepth:
1475   case BuiltinType::OCLImage2dArrayMSAADepth:
1476   case BuiltinType::OCLImage3d:
1477   case BuiltinType::OCLSampler:
1478   case BuiltinType::OCLEvent:
1479   case BuiltinType::OCLClkEvent:
1480   case BuiltinType::OCLQueue:
1481   case BuiltinType::OCLNDRange:
1482   case BuiltinType::OCLReserveID:
1483 #define BUILTIN_TYPE(Id, SingletonId)
1484 #define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1485 #define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id:
1486 #define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id:
1487 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
1488 #include "clang/AST/BuiltinTypes.def"
1489     break;
1490
1491   case BuiltinType::ObjCId:
1492     VisitType = Context.getObjCIdType();
1493     break;
1494
1495   case BuiltinType::ObjCClass:
1496     VisitType = Context.getObjCClassType();
1497     break;
1498
1499   case BuiltinType::ObjCSel:
1500     VisitType = Context.getObjCSelType();
1501     break;
1502   }
1503
1504   if (!VisitType.isNull()) {
1505     if (const TypedefType *Typedef = VisitType->getAs<TypedefType>())
1506       return Visit(MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(),
1507                                      TU));
1508   }
1509
1510   return false;
1511 }
1512
1513 bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
1514   return Visit(MakeCursorTypeRef(TL.getTypedefNameDecl(), TL.getNameLoc(), TU));
1515 }
1516
1517 bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
1518   return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1519 }
1520
1521 bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) {
1522   if (TL.isDefinition())
1523     return Visit(MakeCXCursor(TL.getDecl(), TU, RegionOfInterest));
1524
1525   return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1526 }
1527
1528 bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
1529   return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1530 }
1531
1532 bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
1533   return Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU));
1534 }
1535
1536 bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
1537   if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc()))
1538     return true;
1539
1540   for (unsigned I = 0, N = TL.getNumTypeArgs(); I != N; ++I) {
1541     if (Visit(TL.getTypeArgTInfo(I)->getTypeLoc()))
1542       return true;
1543   }
1544
1545   for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
1546     if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I),
1547                                         TU)))
1548       return true;
1549   }
1550
1551   return false;
1552 }
1553
1554 bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
1555   return Visit(TL.getPointeeLoc());
1556 }
1557
1558 bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) {
1559   return Visit(TL.getInnerLoc());
1560 }
1561
1562 bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) {
1563   return Visit(TL.getPointeeLoc());
1564 }
1565
1566 bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
1567   return Visit(TL.getPointeeLoc());
1568 }
1569
1570 bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
1571   return Visit(TL.getPointeeLoc());
1572 }
1573
1574 bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
1575   return Visit(TL.getPointeeLoc());
1576 }
1577
1578 bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
1579   return Visit(TL.getPointeeLoc());
1580 }
1581
1582 bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
1583   return Visit(TL.getModifiedLoc());
1584 }
1585
1586 bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL,
1587                                          bool SkipResultType) {
1588   if (!SkipResultType && Visit(TL.getReturnLoc()))
1589     return true;
1590
1591   for (unsigned I = 0, N = TL.getNumParams(); I != N; ++I)
1592     if (Decl *D = TL.getParam(I))
1593       if (Visit(MakeCXCursor(D, TU, RegionOfInterest)))
1594         return true;
1595
1596   return false;
1597 }
1598
1599 bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) {
1600   if (Visit(TL.getElementLoc()))
1601     return true;
1602
1603   if (Expr *Size = TL.getSizeExpr())
1604     return Visit(MakeCXCursor(Size, StmtParent, TU, RegionOfInterest));
1605
1606   return false;
1607 }
1608
1609 bool CursorVisitor::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
1610   return Visit(TL.getOriginalLoc());
1611 }
1612
1613 bool CursorVisitor::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
1614   return Visit(TL.getOriginalLoc());
1615 }
1616
1617 bool CursorVisitor::VisitTemplateSpecializationTypeLoc(
1618                                              TemplateSpecializationTypeLoc TL) {
1619   // Visit the template name.
1620   if (VisitTemplateName(TL.getTypePtr()->getTemplateName(),
1621                         TL.getTemplateNameLoc()))
1622     return true;
1623
1624   // Visit the template arguments.
1625   for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1626     if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
1627       return true;
1628
1629   return false;
1630 }
1631
1632 bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
1633   return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU));
1634 }
1635
1636 bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
1637   if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
1638     return Visit(TSInfo->getTypeLoc());
1639
1640   return false;
1641 }
1642
1643 bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
1644   if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
1645     return Visit(TSInfo->getTypeLoc());
1646
1647   return false;
1648 }
1649
1650 bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
1651   return VisitNestedNameSpecifierLoc(TL.getQualifierLoc());
1652 }
1653
1654 bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc(
1655                                     DependentTemplateSpecializationTypeLoc TL) {
1656   // Visit the nested-name-specifier, if there is one.
1657   if (TL.getQualifierLoc() &&
1658       VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1659     return true;
1660
1661   // Visit the template arguments.
1662   for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1663     if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
1664       return true;
1665
1666   return false;
1667 }
1668
1669 bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
1670   if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1671     return true;
1672
1673   return Visit(TL.getNamedTypeLoc());
1674 }
1675
1676 bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
1677   return Visit(TL.getPatternLoc());
1678 }
1679
1680 bool CursorVisitor::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
1681   if (Expr *E = TL.getUnderlyingExpr())
1682     return Visit(MakeCXCursor(E, StmtParent, TU));
1683
1684   return false;
1685 }
1686
1687 bool CursorVisitor::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
1688   return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1689 }
1690
1691 bool CursorVisitor::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
1692   return Visit(TL.getValueLoc());
1693 }
1694
1695 #define DEFAULT_TYPELOC_IMPL(CLASS, PARENT) \
1696 bool CursorVisitor::Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { \
1697   return Visit##PARENT##Loc(TL); \
1698 }
1699
1700 DEFAULT_TYPELOC_IMPL(Complex, Type)
1701 DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType)
1702 DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType)
1703 DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType)
1704 DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType)
1705 DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type)
1706 DEFAULT_TYPELOC_IMPL(Vector, Type)
1707 DEFAULT_TYPELOC_IMPL(ExtVector, VectorType)
1708 DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType)
1709 DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType)
1710 DEFAULT_TYPELOC_IMPL(Record, TagType)
1711 DEFAULT_TYPELOC_IMPL(Enum, TagType)
1712 DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type)
1713 DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type)
1714 DEFAULT_TYPELOC_IMPL(Auto, Type)
1715
1716 bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) {
1717   // Visit the nested-name-specifier, if present.
1718   if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1719     if (VisitNestedNameSpecifierLoc(QualifierLoc))
1720       return true;
1721
1722   if (D->isCompleteDefinition()) {
1723     for (const auto &I : D->bases()) {
1724       if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(&I, TU)))
1725         return true;
1726     }
1727   }
1728
1729   return VisitTagDecl(D);
1730 }
1731
1732 bool CursorVisitor::VisitAttributes(Decl *D) {
1733   for (const auto *I : D->attrs())
1734     if (Visit(MakeCXCursor(I, D, TU)))
1735         return true;
1736
1737   return false;
1738 }
1739
1740 //===----------------------------------------------------------------------===//
1741 // Data-recursive visitor methods.
1742 //===----------------------------------------------------------------------===//
1743
1744 namespace {
1745 #define DEF_JOB(NAME, DATA, KIND)\
1746 class NAME : public VisitorJob {\
1747 public:\
1748   NAME(const DATA *d, CXCursor parent) : \
1749       VisitorJob(parent, VisitorJob::KIND, d) {} \
1750   static bool classof(const VisitorJob *VJ) { return VJ->getKind() == KIND; }\
1751   const DATA *get() const { return static_cast<const DATA*>(data[0]); }\
1752 };
1753
1754 DEF_JOB(StmtVisit, Stmt, StmtVisitKind)
1755 DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind)
1756 DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind)
1757 DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind)
1758 DEF_JOB(ExplicitTemplateArgsVisit, ASTTemplateArgumentListInfo,
1759         ExplicitTemplateArgsVisitKind)
1760 DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind)
1761 DEF_JOB(LambdaExprParts, LambdaExpr, LambdaExprPartsKind)
1762 DEF_JOB(PostChildrenVisit, void, PostChildrenVisitKind)
1763 #undef DEF_JOB
1764
1765 class DeclVisit : public VisitorJob {
1766 public:
1767   DeclVisit(const Decl *D, CXCursor parent, bool isFirst) :
1768     VisitorJob(parent, VisitorJob::DeclVisitKind,
1769                D, isFirst ? (void*) 1 : (void*) nullptr) {}
1770   static bool classof(const VisitorJob *VJ) {
1771     return VJ->getKind() == DeclVisitKind;
1772   }
1773   const Decl *get() const { return static_cast<const Decl *>(data[0]); }
1774   bool isFirst() const { return data[1] != nullptr; }
1775 };
1776 class TypeLocVisit : public VisitorJob {
1777 public:
1778   TypeLocVisit(TypeLoc tl, CXCursor parent) :
1779     VisitorJob(parent, VisitorJob::TypeLocVisitKind,
1780                tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {}
1781
1782   static bool classof(const VisitorJob *VJ) {
1783     return VJ->getKind() == TypeLocVisitKind;
1784   }
1785
1786   TypeLoc get() const {
1787     QualType T = QualType::getFromOpaquePtr(data[0]);
1788     return TypeLoc(T, const_cast<void *>(data[1]));
1789   }
1790 };
1791
1792 class LabelRefVisit : public VisitorJob {
1793 public:
1794   LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent)
1795     : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD,
1796                  labelLoc.getPtrEncoding()) {}
1797
1798   static bool classof(const VisitorJob *VJ) {
1799     return VJ->getKind() == VisitorJob::LabelRefVisitKind;
1800   }
1801   const LabelDecl *get() const {
1802     return static_cast<const LabelDecl *>(data[0]);
1803   }
1804   SourceLocation getLoc() const {
1805     return SourceLocation::getFromPtrEncoding(data[1]); }
1806 };
1807
1808 class NestedNameSpecifierLocVisit : public VisitorJob {
1809 public:
1810   NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent)
1811     : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind,
1812                  Qualifier.getNestedNameSpecifier(),
1813                  Qualifier.getOpaqueData()) { }
1814
1815   static bool classof(const VisitorJob *VJ) {
1816     return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind;
1817   }
1818
1819   NestedNameSpecifierLoc get() const {
1820     return NestedNameSpecifierLoc(
1821             const_cast<NestedNameSpecifier *>(
1822               static_cast<const NestedNameSpecifier *>(data[0])),
1823             const_cast<void *>(data[1]));
1824   }
1825 };
1826
1827 class DeclarationNameInfoVisit : public VisitorJob {
1828 public:
1829   DeclarationNameInfoVisit(const Stmt *S, CXCursor parent)
1830     : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {}
1831   static bool classof(const VisitorJob *VJ) {
1832     return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind;
1833   }
1834   DeclarationNameInfo get() const {
1835     const Stmt *S = static_cast<const Stmt *>(data[0]);
1836     switch (S->getStmtClass()) {
1837     default:
1838       llvm_unreachable("Unhandled Stmt");
1839     case clang::Stmt::MSDependentExistsStmtClass:
1840       return cast<MSDependentExistsStmt>(S)->getNameInfo();
1841     case Stmt::CXXDependentScopeMemberExprClass:
1842       return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo();
1843     case Stmt::DependentScopeDeclRefExprClass:
1844       return cast<DependentScopeDeclRefExpr>(S)->getNameInfo();
1845     case Stmt::OMPCriticalDirectiveClass:
1846       return cast<OMPCriticalDirective>(S)->getDirectiveName();
1847     }
1848   }
1849 };
1850 class MemberRefVisit : public VisitorJob {
1851 public:
1852   MemberRefVisit(const FieldDecl *D, SourceLocation L, CXCursor parent)
1853     : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D,
1854                  L.getPtrEncoding()) {}
1855   static bool classof(const VisitorJob *VJ) {
1856     return VJ->getKind() == VisitorJob::MemberRefVisitKind;
1857   }
1858   const FieldDecl *get() const {
1859     return static_cast<const FieldDecl *>(data[0]);
1860   }
1861   SourceLocation getLoc() const {
1862     return SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[1]);
1863   }
1864 };
1865 class EnqueueVisitor : public ConstStmtVisitor<EnqueueVisitor, void> {
1866   friend class OMPClauseEnqueue;
1867   VisitorWorkList &WL;
1868   CXCursor Parent;
1869 public:
1870   EnqueueVisitor(VisitorWorkList &wl, CXCursor parent)
1871     : WL(wl), Parent(parent) {}
1872
1873   void VisitAddrLabelExpr(const AddrLabelExpr *E);
1874   void VisitBlockExpr(const BlockExpr *B);
1875   void VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
1876   void VisitCompoundStmt(const CompoundStmt *S);
1877   void VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) { /* Do nothing. */ }
1878   void VisitMSDependentExistsStmt(const MSDependentExistsStmt *S);
1879   void VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E);
1880   void VisitCXXNewExpr(const CXXNewExpr *E);
1881   void VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E);
1882   void VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *E);
1883   void VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E);
1884   void VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E);
1885   void VisitCXXTypeidExpr(const CXXTypeidExpr *E);
1886   void VisitCXXUnresolvedConstructExpr(const CXXUnresolvedConstructExpr *E);
1887   void VisitCXXUuidofExpr(const CXXUuidofExpr *E);
1888   void VisitCXXCatchStmt(const CXXCatchStmt *S);
1889   void VisitCXXForRangeStmt(const CXXForRangeStmt *S);
1890   void VisitDeclRefExpr(const DeclRefExpr *D);
1891   void VisitDeclStmt(const DeclStmt *S);
1892   void VisitDependentScopeDeclRefExpr(const DependentScopeDeclRefExpr *E);
1893   void VisitDesignatedInitExpr(const DesignatedInitExpr *E);
1894   void VisitExplicitCastExpr(const ExplicitCastExpr *E);
1895   void VisitForStmt(const ForStmt *FS);
1896   void VisitGotoStmt(const GotoStmt *GS);
1897   void VisitIfStmt(const IfStmt *If);
1898   void VisitInitListExpr(const InitListExpr *IE);
1899   void VisitMemberExpr(const MemberExpr *M);
1900   void VisitOffsetOfExpr(const OffsetOfExpr *E);
1901   void VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
1902   void VisitObjCMessageExpr(const ObjCMessageExpr *M);
1903   void VisitOverloadExpr(const OverloadExpr *E);
1904   void VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
1905   void VisitStmt(const Stmt *S);
1906   void VisitSwitchStmt(const SwitchStmt *S);
1907   void VisitWhileStmt(const WhileStmt *W);
1908   void VisitTypeTraitExpr(const TypeTraitExpr *E);
1909   void VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E);
1910   void VisitExpressionTraitExpr(const ExpressionTraitExpr *E);
1911   void VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U);
1912   void VisitVAArgExpr(const VAArgExpr *E);
1913   void VisitSizeOfPackExpr(const SizeOfPackExpr *E);
1914   void VisitPseudoObjectExpr(const PseudoObjectExpr *E);
1915   void VisitOpaqueValueExpr(const OpaqueValueExpr *E);
1916   void VisitLambdaExpr(const LambdaExpr *E);
1917   void VisitOMPExecutableDirective(const OMPExecutableDirective *D);
1918   void VisitOMPLoopDirective(const OMPLoopDirective *D);
1919   void VisitOMPParallelDirective(const OMPParallelDirective *D);
1920   void VisitOMPSimdDirective(const OMPSimdDirective *D);
1921   void VisitOMPForDirective(const OMPForDirective *D);
1922   void VisitOMPForSimdDirective(const OMPForSimdDirective *D);
1923   void VisitOMPSectionsDirective(const OMPSectionsDirective *D);
1924   void VisitOMPSectionDirective(const OMPSectionDirective *D);
1925   void VisitOMPSingleDirective(const OMPSingleDirective *D);
1926   void VisitOMPMasterDirective(const OMPMasterDirective *D);
1927   void VisitOMPCriticalDirective(const OMPCriticalDirective *D);
1928   void VisitOMPParallelForDirective(const OMPParallelForDirective *D);
1929   void VisitOMPParallelForSimdDirective(const OMPParallelForSimdDirective *D);
1930   void VisitOMPParallelSectionsDirective(const OMPParallelSectionsDirective *D);
1931   void VisitOMPTaskDirective(const OMPTaskDirective *D);
1932   void VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D);
1933   void VisitOMPBarrierDirective(const OMPBarrierDirective *D);
1934   void VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D);
1935   void VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *D);
1936   void
1937   VisitOMPCancellationPointDirective(const OMPCancellationPointDirective *D);
1938   void VisitOMPCancelDirective(const OMPCancelDirective *D);
1939   void VisitOMPFlushDirective(const OMPFlushDirective *D);
1940   void VisitOMPOrderedDirective(const OMPOrderedDirective *D);
1941   void VisitOMPAtomicDirective(const OMPAtomicDirective *D);
1942   void VisitOMPTargetDirective(const OMPTargetDirective *D);
1943   void VisitOMPTargetDataDirective(const OMPTargetDataDirective *D);
1944   void VisitOMPTeamsDirective(const OMPTeamsDirective *D);
1945   void VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D);
1946   void VisitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective *D);
1947   void VisitOMPDistributeDirective(const OMPDistributeDirective *D);
1948
1949 private:
1950   void AddDeclarationNameInfo(const Stmt *S);
1951   void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier);
1952   void AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A);
1953   void AddMemberRef(const FieldDecl *D, SourceLocation L);
1954   void AddStmt(const Stmt *S);
1955   void AddDecl(const Decl *D, bool isFirst = true);
1956   void AddTypeLoc(TypeSourceInfo *TI);
1957   void EnqueueChildren(const Stmt *S);
1958   void EnqueueChildren(const OMPClause *S);
1959 };
1960 } // end anonyous namespace
1961
1962 void EnqueueVisitor::AddDeclarationNameInfo(const Stmt *S) {
1963   // 'S' should always be non-null, since it comes from the
1964   // statement we are visiting.
1965   WL.push_back(DeclarationNameInfoVisit(S, Parent));
1966 }
1967
1968 void
1969 EnqueueVisitor::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) {
1970   if (Qualifier)
1971     WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent));
1972 }
1973
1974 void EnqueueVisitor::AddStmt(const Stmt *S) {
1975   if (S)
1976     WL.push_back(StmtVisit(S, Parent));
1977 }
1978 void EnqueueVisitor::AddDecl(const Decl *D, bool isFirst) {
1979   if (D)
1980     WL.push_back(DeclVisit(D, Parent, isFirst));
1981 }
1982 void EnqueueVisitor::
1983   AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A) {
1984   if (A)
1985     WL.push_back(ExplicitTemplateArgsVisit(A, Parent));
1986 }
1987 void EnqueueVisitor::AddMemberRef(const FieldDecl *D, SourceLocation L) {
1988   if (D)
1989     WL.push_back(MemberRefVisit(D, L, Parent));
1990 }
1991 void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) {
1992   if (TI)
1993     WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent));
1994  }
1995 void EnqueueVisitor::EnqueueChildren(const Stmt *S) {
1996   unsigned size = WL.size();
1997   for (const Stmt *SubStmt : S->children()) {
1998     AddStmt(SubStmt);
1999   }
2000   if (size == WL.size())
2001     return;
2002   // Now reverse the entries we just added.  This will match the DFS
2003   // ordering performed by the worklist.
2004   VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
2005   std::reverse(I, E);
2006 }
2007 namespace {
2008 class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> {
2009   EnqueueVisitor *Visitor;
2010   /// \brief Process clauses with list of variables.
2011   template <typename T>
2012   void VisitOMPClauseList(T *Node);
2013 public:
2014   OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) { }
2015 #define OPENMP_CLAUSE(Name, Class)                                             \
2016   void Visit##Class(const Class *C);
2017 #include "clang/Basic/OpenMPKinds.def"
2018 };
2019
2020 void OMPClauseEnqueue::VisitOMPIfClause(const OMPIfClause *C) {
2021   Visitor->AddStmt(C->getCondition());
2022 }
2023
2024 void OMPClauseEnqueue::VisitOMPFinalClause(const OMPFinalClause *C) {
2025   Visitor->AddStmt(C->getCondition());
2026 }
2027
2028 void OMPClauseEnqueue::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) {
2029   Visitor->AddStmt(C->getNumThreads());
2030 }
2031
2032 void OMPClauseEnqueue::VisitOMPSafelenClause(const OMPSafelenClause *C) {
2033   Visitor->AddStmt(C->getSafelen());
2034 }
2035
2036 void OMPClauseEnqueue::VisitOMPSimdlenClause(const OMPSimdlenClause *C) {
2037   Visitor->AddStmt(C->getSimdlen());
2038 }
2039
2040 void OMPClauseEnqueue::VisitOMPCollapseClause(const OMPCollapseClause *C) {
2041   Visitor->AddStmt(C->getNumForLoops());
2042 }
2043
2044 void OMPClauseEnqueue::VisitOMPDefaultClause(const OMPDefaultClause *C) { }
2045
2046 void OMPClauseEnqueue::VisitOMPProcBindClause(const OMPProcBindClause *C) { }
2047
2048 void OMPClauseEnqueue::VisitOMPScheduleClause(const OMPScheduleClause *C) {
2049   Visitor->AddStmt(C->getChunkSize());
2050   Visitor->AddStmt(C->getHelperChunkSize());
2051 }
2052
2053 void OMPClauseEnqueue::VisitOMPOrderedClause(const OMPOrderedClause *C) {
2054   Visitor->AddStmt(C->getNumForLoops());
2055 }
2056
2057 void OMPClauseEnqueue::VisitOMPNowaitClause(const OMPNowaitClause *) {}
2058
2059 void OMPClauseEnqueue::VisitOMPUntiedClause(const OMPUntiedClause *) {}
2060
2061 void OMPClauseEnqueue::VisitOMPMergeableClause(const OMPMergeableClause *) {}
2062
2063 void OMPClauseEnqueue::VisitOMPReadClause(const OMPReadClause *) {}
2064
2065 void OMPClauseEnqueue::VisitOMPWriteClause(const OMPWriteClause *) {}
2066
2067 void OMPClauseEnqueue::VisitOMPUpdateClause(const OMPUpdateClause *) {}
2068
2069 void OMPClauseEnqueue::VisitOMPCaptureClause(const OMPCaptureClause *) {}
2070
2071 void OMPClauseEnqueue::VisitOMPSeqCstClause(const OMPSeqCstClause *) {}
2072
2073 void OMPClauseEnqueue::VisitOMPThreadsClause(const OMPThreadsClause *) {}
2074
2075 void OMPClauseEnqueue::VisitOMPSIMDClause(const OMPSIMDClause *) {}
2076
2077 void OMPClauseEnqueue::VisitOMPNogroupClause(const OMPNogroupClause *) {}
2078
2079 void OMPClauseEnqueue::VisitOMPDeviceClause(const OMPDeviceClause *C) {
2080   Visitor->AddStmt(C->getDevice());
2081 }
2082
2083 void OMPClauseEnqueue::VisitOMPNumTeamsClause(const OMPNumTeamsClause *C) {
2084   Visitor->AddStmt(C->getNumTeams());
2085 }
2086
2087 void OMPClauseEnqueue::VisitOMPThreadLimitClause(const OMPThreadLimitClause *C) {
2088   Visitor->AddStmt(C->getThreadLimit());
2089 }
2090
2091 void OMPClauseEnqueue::VisitOMPPriorityClause(const OMPPriorityClause *C) {
2092   Visitor->AddStmt(C->getPriority());
2093 }
2094
2095 void OMPClauseEnqueue::VisitOMPGrainsizeClause(const OMPGrainsizeClause *C) {
2096   Visitor->AddStmt(C->getGrainsize());
2097 }
2098
2099 void OMPClauseEnqueue::VisitOMPNumTasksClause(const OMPNumTasksClause *C) {
2100   Visitor->AddStmt(C->getNumTasks());
2101 }
2102
2103 void OMPClauseEnqueue::VisitOMPHintClause(const OMPHintClause *C) {
2104   Visitor->AddStmt(C->getHint());
2105 }
2106
2107 template<typename T>
2108 void OMPClauseEnqueue::VisitOMPClauseList(T *Node) {
2109   for (const auto *I : Node->varlists()) {
2110     Visitor->AddStmt(I);
2111   }
2112 }
2113
2114 void OMPClauseEnqueue::VisitOMPPrivateClause(const OMPPrivateClause *C) {
2115   VisitOMPClauseList(C);
2116   for (const auto *E : C->private_copies()) {
2117     Visitor->AddStmt(E);
2118   }
2119 }
2120 void OMPClauseEnqueue::VisitOMPFirstprivateClause(
2121                                         const OMPFirstprivateClause *C) {
2122   VisitOMPClauseList(C);
2123 }
2124 void OMPClauseEnqueue::VisitOMPLastprivateClause(
2125                                         const OMPLastprivateClause *C) {
2126   VisitOMPClauseList(C);
2127   for (auto *E : C->private_copies()) {
2128     Visitor->AddStmt(E);
2129   }
2130   for (auto *E : C->source_exprs()) {
2131     Visitor->AddStmt(E);
2132   }
2133   for (auto *E : C->destination_exprs()) {
2134     Visitor->AddStmt(E);
2135   }
2136   for (auto *E : C->assignment_ops()) {
2137     Visitor->AddStmt(E);
2138   }
2139 }
2140 void OMPClauseEnqueue::VisitOMPSharedClause(const OMPSharedClause *C) {
2141   VisitOMPClauseList(C);
2142 }
2143 void OMPClauseEnqueue::VisitOMPReductionClause(const OMPReductionClause *C) {
2144   VisitOMPClauseList(C);
2145   for (auto *E : C->privates()) {
2146     Visitor->AddStmt(E);
2147   }
2148   for (auto *E : C->lhs_exprs()) {
2149     Visitor->AddStmt(E);
2150   }
2151   for (auto *E : C->rhs_exprs()) {
2152     Visitor->AddStmt(E);
2153   }
2154   for (auto *E : C->reduction_ops()) {
2155     Visitor->AddStmt(E);
2156   }
2157 }
2158 void OMPClauseEnqueue::VisitOMPLinearClause(const OMPLinearClause *C) {
2159   VisitOMPClauseList(C);
2160   for (const auto *E : C->privates()) {
2161     Visitor->AddStmt(E);
2162   }
2163   for (const auto *E : C->inits()) {
2164     Visitor->AddStmt(E);
2165   }
2166   for (const auto *E : C->updates()) {
2167     Visitor->AddStmt(E);
2168   }
2169   for (const auto *E : C->finals()) {
2170     Visitor->AddStmt(E);
2171   }
2172   Visitor->AddStmt(C->getStep());
2173   Visitor->AddStmt(C->getCalcStep());
2174 }
2175 void OMPClauseEnqueue::VisitOMPAlignedClause(const OMPAlignedClause *C) {
2176   VisitOMPClauseList(C);
2177   Visitor->AddStmt(C->getAlignment());
2178 }
2179 void OMPClauseEnqueue::VisitOMPCopyinClause(const OMPCopyinClause *C) {
2180   VisitOMPClauseList(C);
2181   for (auto *E : C->source_exprs()) {
2182     Visitor->AddStmt(E);
2183   }
2184   for (auto *E : C->destination_exprs()) {
2185     Visitor->AddStmt(E);
2186   }
2187   for (auto *E : C->assignment_ops()) {
2188     Visitor->AddStmt(E);
2189   }
2190 }
2191 void
2192 OMPClauseEnqueue::VisitOMPCopyprivateClause(const OMPCopyprivateClause *C) {
2193   VisitOMPClauseList(C);
2194   for (auto *E : C->source_exprs()) {
2195     Visitor->AddStmt(E);
2196   }
2197   for (auto *E : C->destination_exprs()) {
2198     Visitor->AddStmt(E);
2199   }
2200   for (auto *E : C->assignment_ops()) {
2201     Visitor->AddStmt(E);
2202   }
2203 }
2204 void OMPClauseEnqueue::VisitOMPFlushClause(const OMPFlushClause *C) {
2205   VisitOMPClauseList(C);
2206 }
2207 void OMPClauseEnqueue::VisitOMPDependClause(const OMPDependClause *C) {
2208   VisitOMPClauseList(C);
2209 }
2210 void OMPClauseEnqueue::VisitOMPMapClause(const OMPMapClause *C) {
2211   VisitOMPClauseList(C);
2212 }
2213 }
2214
2215 void EnqueueVisitor::EnqueueChildren(const OMPClause *S) {
2216   unsigned size = WL.size();
2217   OMPClauseEnqueue Visitor(this);
2218   Visitor.Visit(S);
2219   if (size == WL.size())
2220     return;
2221   // Now reverse the entries we just added.  This will match the DFS
2222   // ordering performed by the worklist.
2223   VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
2224   std::reverse(I, E);
2225 }
2226 void EnqueueVisitor::VisitAddrLabelExpr(const AddrLabelExpr *E) {
2227   WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent));
2228 }
2229 void EnqueueVisitor::VisitBlockExpr(const BlockExpr *B) {
2230   AddDecl(B->getBlockDecl());
2231 }
2232 void EnqueueVisitor::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
2233   EnqueueChildren(E);
2234   AddTypeLoc(E->getTypeSourceInfo());
2235 }
2236 void EnqueueVisitor::VisitCompoundStmt(const CompoundStmt *S) {
2237   for (auto &I : llvm::reverse(S->body()))
2238     AddStmt(I);
2239 }
2240 void EnqueueVisitor::
2241 VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) {
2242   AddStmt(S->getSubStmt());
2243   AddDeclarationNameInfo(S);
2244   if (NestedNameSpecifierLoc QualifierLoc = S->getQualifierLoc())
2245     AddNestedNameSpecifierLoc(QualifierLoc);
2246 }
2247
2248 void EnqueueVisitor::
2249 VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *E) {
2250   AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs());
2251   AddDeclarationNameInfo(E);
2252   if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
2253     AddNestedNameSpecifierLoc(QualifierLoc);
2254   if (!E->isImplicitAccess())
2255     AddStmt(E->getBase());
2256 }
2257 void EnqueueVisitor::VisitCXXNewExpr(const CXXNewExpr *E) {
2258   // Enqueue the initializer , if any.
2259   AddStmt(E->getInitializer());
2260   // Enqueue the array size, if any.
2261   AddStmt(E->getArraySize());
2262   // Enqueue the allocated type.
2263   AddTypeLoc(E->getAllocatedTypeSourceInfo());
2264   // Enqueue the placement arguments.
2265   for (unsigned I = E->getNumPlacementArgs(); I > 0; --I)
2266     AddStmt(E->getPlacementArg(I-1));
2267 }
2268 void EnqueueVisitor::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *CE) {
2269   for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I)
2270     AddStmt(CE->getArg(I-1));
2271   AddStmt(CE->getCallee());
2272   AddStmt(CE->getArg(0));
2273 }
2274 void EnqueueVisitor::VisitCXXPseudoDestructorExpr(
2275                                         const CXXPseudoDestructorExpr *E) {
2276   // Visit the name of the type being destroyed.
2277   AddTypeLoc(E->getDestroyedTypeInfo());
2278   // Visit the scope type that looks disturbingly like the nested-name-specifier
2279   // but isn't.
2280   AddTypeLoc(E->getScopeTypeInfo());
2281   // Visit the nested-name-specifier.
2282   if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
2283     AddNestedNameSpecifierLoc(QualifierLoc);
2284   // Visit base expression.
2285   AddStmt(E->getBase());
2286 }
2287 void EnqueueVisitor::VisitCXXScalarValueInitExpr(
2288                                         const CXXScalarValueInitExpr *E) {
2289   AddTypeLoc(E->getTypeSourceInfo());
2290 }
2291 void EnqueueVisitor::VisitCXXTemporaryObjectExpr(
2292                                         const CXXTemporaryObjectExpr *E) {
2293   EnqueueChildren(E);
2294   AddTypeLoc(E->getTypeSourceInfo());
2295 }
2296 void EnqueueVisitor::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
2297   EnqueueChildren(E);
2298   if (E->isTypeOperand())
2299     AddTypeLoc(E->getTypeOperandSourceInfo());
2300 }
2301
2302 void EnqueueVisitor::VisitCXXUnresolvedConstructExpr(
2303                                         const CXXUnresolvedConstructExpr *E) {
2304   EnqueueChildren(E);
2305   AddTypeLoc(E->getTypeSourceInfo());
2306 }
2307 void EnqueueVisitor::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
2308   EnqueueChildren(E);
2309   if (E->isTypeOperand())
2310     AddTypeLoc(E->getTypeOperandSourceInfo());
2311 }
2312
2313 void EnqueueVisitor::VisitCXXCatchStmt(const CXXCatchStmt *S) {
2314   EnqueueChildren(S);
2315   AddDecl(S->getExceptionDecl());
2316 }
2317
2318 void EnqueueVisitor::VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
2319   AddStmt(S->getBody());
2320   AddStmt(S->getRangeInit());
2321   AddDecl(S->getLoopVariable());
2322 }
2323
2324 void EnqueueVisitor::VisitDeclRefExpr(const DeclRefExpr *DR) {
2325   if (DR->hasExplicitTemplateArgs()) {
2326     AddExplicitTemplateArgs(&DR->getExplicitTemplateArgs());
2327   }
2328   WL.push_back(DeclRefExprParts(DR, Parent));
2329 }
2330 void EnqueueVisitor::VisitDependentScopeDeclRefExpr(
2331                                         const DependentScopeDeclRefExpr *E) {
2332   AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs());
2333   AddDeclarationNameInfo(E);
2334   AddNestedNameSpecifierLoc(E->getQualifierLoc());
2335 }
2336 void EnqueueVisitor::VisitDeclStmt(const DeclStmt *S) {
2337   unsigned size = WL.size();
2338   bool isFirst = true;
2339   for (const auto *D : S->decls()) {
2340     AddDecl(D, isFirst);
2341     isFirst = false;
2342   }
2343   if (size == WL.size())
2344     return;
2345   // Now reverse the entries we just added.  This will match the DFS
2346   // ordering performed by the worklist.
2347   VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
2348   std::reverse(I, E);
2349 }
2350 void EnqueueVisitor::VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
2351   AddStmt(E->getInit());
2352   for (DesignatedInitExpr::const_reverse_designators_iterator
2353          D = E->designators_rbegin(), DEnd = E->designators_rend();
2354          D != DEnd; ++D) {
2355     if (D->isFieldDesignator()) {
2356       if (FieldDecl *Field = D->getField())
2357         AddMemberRef(Field, D->getFieldLoc());
2358       continue;
2359     }
2360     if (D->isArrayDesignator()) {
2361       AddStmt(E->getArrayIndex(*D));
2362       continue;
2363     }
2364     assert(D->isArrayRangeDesignator() && "Unknown designator kind");
2365     AddStmt(E->getArrayRangeEnd(*D));
2366     AddStmt(E->getArrayRangeStart(*D));
2367   }
2368 }
2369 void EnqueueVisitor::VisitExplicitCastExpr(const ExplicitCastExpr *E) {
2370   EnqueueChildren(E);
2371   AddTypeLoc(E->getTypeInfoAsWritten());
2372 }
2373 void EnqueueVisitor::VisitForStmt(const ForStmt *FS) {
2374   AddStmt(FS->getBody());
2375   AddStmt(FS->getInc());
2376   AddStmt(FS->getCond());
2377   AddDecl(FS->getConditionVariable());
2378   AddStmt(FS->getInit());
2379 }
2380 void EnqueueVisitor::VisitGotoStmt(const GotoStmt *GS) {
2381   WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent));
2382 }
2383 void EnqueueVisitor::VisitIfStmt(const IfStmt *If) {
2384   AddStmt(If->getElse());
2385   AddStmt(If->getThen());
2386   AddStmt(If->getCond());
2387   AddDecl(If->getConditionVariable());
2388 }
2389 void EnqueueVisitor::VisitInitListExpr(const InitListExpr *IE) {
2390   // We care about the syntactic form of the initializer list, only.
2391   if (InitListExpr *Syntactic = IE->getSyntacticForm())
2392     IE = Syntactic;
2393   EnqueueChildren(IE);
2394 }
2395 void EnqueueVisitor::VisitMemberExpr(const MemberExpr *M) {
2396   WL.push_back(MemberExprParts(M, Parent));
2397
2398   // If the base of the member access expression is an implicit 'this', don't
2399   // visit it.
2400   // FIXME: If we ever want to show these implicit accesses, this will be
2401   // unfortunate. However, clang_getCursor() relies on this behavior.
2402   if (M->isImplicitAccess())
2403     return;
2404
2405   // Ignore base anonymous struct/union fields, otherwise they will shadow the
2406   // real field that that we are interested in.
2407   if (auto *SubME = dyn_cast<MemberExpr>(M->getBase())) {
2408     if (auto *FD = dyn_cast_or_null<FieldDecl>(SubME->getMemberDecl())) {
2409       if (FD->isAnonymousStructOrUnion()) {
2410         AddStmt(SubME->getBase());
2411         return;
2412       }
2413     }
2414   }
2415
2416   AddStmt(M->getBase());
2417 }
2418 void EnqueueVisitor::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
2419   AddTypeLoc(E->getEncodedTypeSourceInfo());
2420 }
2421 void EnqueueVisitor::VisitObjCMessageExpr(const ObjCMessageExpr *M) {
2422   EnqueueChildren(M);
2423   AddTypeLoc(M->getClassReceiverTypeInfo());
2424 }
2425 void EnqueueVisitor::VisitOffsetOfExpr(const OffsetOfExpr *E) {
2426   // Visit the components of the offsetof expression.
2427   for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) {
2428     typedef OffsetOfExpr::OffsetOfNode OffsetOfNode;
2429     const OffsetOfNode &Node = E->getComponent(I-1);
2430     switch (Node.getKind()) {
2431     case OffsetOfNode::Array:
2432       AddStmt(E->getIndexExpr(Node.getArrayExprIndex()));
2433       break;
2434     case OffsetOfNode::Field:
2435       AddMemberRef(Node.getField(), Node.getSourceRange().getEnd());
2436       break;
2437     case OffsetOfNode::Identifier:
2438     case OffsetOfNode::Base:
2439       continue;
2440     }
2441   }
2442   // Visit the type into which we're computing the offset.
2443   AddTypeLoc(E->getTypeSourceInfo());
2444 }
2445 void EnqueueVisitor::VisitOverloadExpr(const OverloadExpr *E) {
2446   AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs());
2447   WL.push_back(OverloadExprParts(E, Parent));
2448 }
2449 void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr(
2450                                         const UnaryExprOrTypeTraitExpr *E) {
2451   EnqueueChildren(E);
2452   if (E->isArgumentType())
2453     AddTypeLoc(E->getArgumentTypeInfo());
2454 }
2455 void EnqueueVisitor::VisitStmt(const Stmt *S) {
2456   EnqueueChildren(S);
2457 }
2458 void EnqueueVisitor::VisitSwitchStmt(const SwitchStmt *S) {
2459   AddStmt(S->getBody());
2460   AddStmt(S->getCond());
2461   AddDecl(S->getConditionVariable());
2462 }
2463
2464 void EnqueueVisitor::VisitWhileStmt(const WhileStmt *W) {
2465   AddStmt(W->getBody());
2466   AddStmt(W->getCond());
2467   AddDecl(W->getConditionVariable());
2468 }
2469
2470 void EnqueueVisitor::VisitTypeTraitExpr(const TypeTraitExpr *E) {
2471   for (unsigned I = E->getNumArgs(); I > 0; --I)
2472     AddTypeLoc(E->getArg(I-1));
2473 }
2474
2475 void EnqueueVisitor::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
2476   AddTypeLoc(E->getQueriedTypeSourceInfo());
2477 }
2478
2479 void EnqueueVisitor::VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
2480   EnqueueChildren(E);
2481 }
2482
2483 void EnqueueVisitor::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *U) {
2484   VisitOverloadExpr(U);
2485   if (!U->isImplicitAccess())
2486     AddStmt(U->getBase());
2487 }
2488 void EnqueueVisitor::VisitVAArgExpr(const VAArgExpr *E) {
2489   AddStmt(E->getSubExpr());
2490   AddTypeLoc(E->getWrittenTypeInfo());
2491 }
2492 void EnqueueVisitor::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
2493   WL.push_back(SizeOfPackExprParts(E, Parent));
2494 }
2495 void EnqueueVisitor::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
2496   // If the opaque value has a source expression, just transparently
2497   // visit that.  This is useful for (e.g.) pseudo-object expressions.
2498   if (Expr *SourceExpr = E->getSourceExpr())
2499     return Visit(SourceExpr);
2500 }
2501 void EnqueueVisitor::VisitLambdaExpr(const LambdaExpr *E) {
2502   AddStmt(E->getBody());
2503   WL.push_back(LambdaExprParts(E, Parent));
2504 }
2505 void EnqueueVisitor::VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
2506   // Treat the expression like its syntactic form.
2507   Visit(E->getSyntacticForm());
2508 }
2509
2510 void EnqueueVisitor::VisitOMPExecutableDirective(
2511   const OMPExecutableDirective *D) {
2512   EnqueueChildren(D);
2513   for (ArrayRef<OMPClause *>::iterator I = D->clauses().begin(),
2514                                        E = D->clauses().end();
2515        I != E; ++I)
2516     EnqueueChildren(*I);
2517 }
2518
2519 void EnqueueVisitor::VisitOMPLoopDirective(const OMPLoopDirective *D) {
2520   VisitOMPExecutableDirective(D);
2521 }
2522
2523 void EnqueueVisitor::VisitOMPParallelDirective(const OMPParallelDirective *D) {
2524   VisitOMPExecutableDirective(D);
2525 }
2526
2527 void EnqueueVisitor::VisitOMPSimdDirective(const OMPSimdDirective *D) {
2528   VisitOMPLoopDirective(D);
2529 }
2530
2531 void EnqueueVisitor::VisitOMPForDirective(const OMPForDirective *D) {
2532   VisitOMPLoopDirective(D);
2533 }
2534
2535 void EnqueueVisitor::VisitOMPForSimdDirective(const OMPForSimdDirective *D) {
2536   VisitOMPLoopDirective(D);
2537 }
2538
2539 void EnqueueVisitor::VisitOMPSectionsDirective(const OMPSectionsDirective *D) {
2540   VisitOMPExecutableDirective(D);
2541 }
2542
2543 void EnqueueVisitor::VisitOMPSectionDirective(const OMPSectionDirective *D) {
2544   VisitOMPExecutableDirective(D);
2545 }
2546
2547 void EnqueueVisitor::VisitOMPSingleDirective(const OMPSingleDirective *D) {
2548   VisitOMPExecutableDirective(D);
2549 }
2550
2551 void EnqueueVisitor::VisitOMPMasterDirective(const OMPMasterDirective *D) {
2552   VisitOMPExecutableDirective(D);
2553 }
2554
2555 void EnqueueVisitor::VisitOMPCriticalDirective(const OMPCriticalDirective *D) {
2556   VisitOMPExecutableDirective(D);
2557   AddDeclarationNameInfo(D);
2558 }
2559
2560 void
2561 EnqueueVisitor::VisitOMPParallelForDirective(const OMPParallelForDirective *D) {
2562   VisitOMPLoopDirective(D);
2563 }
2564
2565 void EnqueueVisitor::VisitOMPParallelForSimdDirective(
2566     const OMPParallelForSimdDirective *D) {
2567   VisitOMPLoopDirective(D);
2568 }
2569
2570 void EnqueueVisitor::VisitOMPParallelSectionsDirective(
2571     const OMPParallelSectionsDirective *D) {
2572   VisitOMPExecutableDirective(D);
2573 }
2574
2575 void EnqueueVisitor::VisitOMPTaskDirective(const OMPTaskDirective *D) {
2576   VisitOMPExecutableDirective(D);
2577 }
2578
2579 void
2580 EnqueueVisitor::VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D) {
2581   VisitOMPExecutableDirective(D);
2582 }
2583
2584 void EnqueueVisitor::VisitOMPBarrierDirective(const OMPBarrierDirective *D) {
2585   VisitOMPExecutableDirective(D);
2586 }
2587
2588 void EnqueueVisitor::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D) {
2589   VisitOMPExecutableDirective(D);
2590 }
2591
2592 void EnqueueVisitor::VisitOMPTaskgroupDirective(
2593     const OMPTaskgroupDirective *D) {
2594   VisitOMPExecutableDirective(D);
2595 }
2596
2597 void EnqueueVisitor::VisitOMPFlushDirective(const OMPFlushDirective *D) {
2598   VisitOMPExecutableDirective(D);
2599 }
2600
2601 void EnqueueVisitor::VisitOMPOrderedDirective(const OMPOrderedDirective *D) {
2602   VisitOMPExecutableDirective(D);
2603 }
2604
2605 void EnqueueVisitor::VisitOMPAtomicDirective(const OMPAtomicDirective *D) {
2606   VisitOMPExecutableDirective(D);
2607 }
2608
2609 void EnqueueVisitor::VisitOMPTargetDirective(const OMPTargetDirective *D) {
2610   VisitOMPExecutableDirective(D);
2611 }
2612
2613 void EnqueueVisitor::VisitOMPTargetDataDirective(const
2614                                                  OMPTargetDataDirective *D) {
2615   VisitOMPExecutableDirective(D);
2616 }
2617
2618 void EnqueueVisitor::VisitOMPTeamsDirective(const OMPTeamsDirective *D) {
2619   VisitOMPExecutableDirective(D);
2620 }
2621
2622 void EnqueueVisitor::VisitOMPCancellationPointDirective(
2623     const OMPCancellationPointDirective *D) {
2624   VisitOMPExecutableDirective(D);
2625 }
2626
2627 void EnqueueVisitor::VisitOMPCancelDirective(const OMPCancelDirective *D) {
2628   VisitOMPExecutableDirective(D);
2629 }
2630
2631 void EnqueueVisitor::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *D) {
2632   VisitOMPLoopDirective(D);
2633 }
2634
2635 void EnqueueVisitor::VisitOMPTaskLoopSimdDirective(
2636     const OMPTaskLoopSimdDirective *D) {
2637   VisitOMPLoopDirective(D);
2638 }
2639
2640 void EnqueueVisitor::VisitOMPDistributeDirective(
2641     const OMPDistributeDirective *D) {
2642   VisitOMPLoopDirective(D);
2643 }
2644
2645 void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) {
2646   EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S);
2647 }
2648
2649 bool CursorVisitor::IsInRegionOfInterest(CXCursor C) {
2650   if (RegionOfInterest.isValid()) {
2651     SourceRange Range = getRawCursorExtent(C);
2652     if (Range.isInvalid() || CompareRegionOfInterest(Range))
2653       return false;
2654   }
2655   return true;
2656 }
2657
2658 bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) {
2659   while (!WL.empty()) {
2660     // Dequeue the worklist item.
2661     VisitorJob LI = WL.pop_back_val();
2662
2663     // Set the Parent field, then back to its old value once we're done.
2664     SetParentRAII SetParent(Parent, StmtParent, LI.getParent());
2665
2666     switch (LI.getKind()) {
2667       case VisitorJob::DeclVisitKind: {
2668         const Decl *D = cast<DeclVisit>(&LI)->get();
2669         if (!D)
2670           continue;
2671
2672         // For now, perform default visitation for Decls.
2673         if (Visit(MakeCXCursor(D, TU, RegionOfInterest,
2674                                cast<DeclVisit>(&LI)->isFirst())))
2675             return true;
2676
2677         continue;
2678       }
2679       case VisitorJob::ExplicitTemplateArgsVisitKind: {
2680         const ASTTemplateArgumentListInfo *ArgList =
2681           cast<ExplicitTemplateArgsVisit>(&LI)->get();
2682         for (const TemplateArgumentLoc *Arg = ArgList->getTemplateArgs(),
2683                *ArgEnd = Arg + ArgList->NumTemplateArgs;
2684                Arg != ArgEnd; ++Arg) {
2685           if (VisitTemplateArgumentLoc(*Arg))
2686             return true;
2687         }
2688         continue;
2689       }
2690       case VisitorJob::TypeLocVisitKind: {
2691         // Perform default visitation for TypeLocs.
2692         if (Visit(cast<TypeLocVisit>(&LI)->get()))
2693           return true;
2694         continue;
2695       }
2696       case VisitorJob::LabelRefVisitKind: {
2697         const LabelDecl *LS = cast<LabelRefVisit>(&LI)->get();
2698         if (LabelStmt *stmt = LS->getStmt()) {
2699           if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(),
2700                                        TU))) {
2701             return true;
2702           }
2703         }
2704         continue;
2705       }
2706
2707       case VisitorJob::NestedNameSpecifierLocVisitKind: {
2708         NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI);
2709         if (VisitNestedNameSpecifierLoc(V->get()))
2710           return true;
2711         continue;
2712       }
2713
2714       case VisitorJob::DeclarationNameInfoVisitKind: {
2715         if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI)
2716                                      ->get()))
2717           return true;
2718         continue;
2719       }
2720       case VisitorJob::MemberRefVisitKind: {
2721         MemberRefVisit *V = cast<MemberRefVisit>(&LI);
2722         if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU)))
2723           return true;
2724         continue;
2725       }
2726       case VisitorJob::StmtVisitKind: {
2727         const Stmt *S = cast<StmtVisit>(&LI)->get();
2728         if (!S)
2729           continue;
2730
2731         // Update the current cursor.
2732         CXCursor Cursor = MakeCXCursor(S, StmtParent, TU, RegionOfInterest);
2733         if (!IsInRegionOfInterest(Cursor))
2734           continue;
2735         switch (Visitor(Cursor, Parent, ClientData)) {
2736           case CXChildVisit_Break: return true;
2737           case CXChildVisit_Continue: break;
2738           case CXChildVisit_Recurse:
2739             if (PostChildrenVisitor)
2740               WL.push_back(PostChildrenVisit(nullptr, Cursor));
2741             EnqueueWorkList(WL, S);
2742             break;
2743         }
2744         continue;
2745       }
2746       case VisitorJob::MemberExprPartsKind: {
2747         // Handle the other pieces in the MemberExpr besides the base.
2748         const MemberExpr *M = cast<MemberExprParts>(&LI)->get();
2749
2750         // Visit the nested-name-specifier
2751         if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc())
2752           if (VisitNestedNameSpecifierLoc(QualifierLoc))
2753             return true;
2754
2755         // Visit the declaration name.
2756         if (VisitDeclarationNameInfo(M->getMemberNameInfo()))
2757           return true;
2758
2759         // Visit the explicitly-specified template arguments, if any.
2760         if (M->hasExplicitTemplateArgs()) {
2761           for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(),
2762                *ArgEnd = Arg + M->getNumTemplateArgs();
2763                Arg != ArgEnd; ++Arg) {
2764             if (VisitTemplateArgumentLoc(*Arg))
2765               return true;
2766           }
2767         }
2768         continue;
2769       }
2770       case VisitorJob::DeclRefExprPartsKind: {
2771         const DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get();
2772         // Visit nested-name-specifier, if present.
2773         if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc())
2774           if (VisitNestedNameSpecifierLoc(QualifierLoc))
2775             return true;
2776         // Visit declaration name.
2777         if (VisitDeclarationNameInfo(DR->getNameInfo()))
2778           return true;
2779         continue;
2780       }
2781       case VisitorJob::OverloadExprPartsKind: {
2782         const OverloadExpr *O = cast<OverloadExprParts>(&LI)->get();
2783         // Visit the nested-name-specifier.
2784         if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc())
2785           if (VisitNestedNameSpecifierLoc(QualifierLoc))
2786             return true;
2787         // Visit the declaration name.
2788         if (VisitDeclarationNameInfo(O->getNameInfo()))
2789           return true;
2790         // Visit the overloaded declaration reference.
2791         if (Visit(MakeCursorOverloadedDeclRef(O, TU)))
2792           return true;
2793         continue;
2794       }
2795       case VisitorJob::SizeOfPackExprPartsKind: {
2796         const SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get();
2797         NamedDecl *Pack = E->getPack();
2798         if (isa<TemplateTypeParmDecl>(Pack)) {
2799           if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack),
2800                                       E->getPackLoc(), TU)))
2801             return true;
2802
2803           continue;
2804         }
2805
2806         if (isa<TemplateTemplateParmDecl>(Pack)) {
2807           if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack),
2808                                           E->getPackLoc(), TU)))
2809             return true;
2810
2811           continue;
2812         }
2813
2814         // Non-type template parameter packs and function parameter packs are
2815         // treated like DeclRefExpr cursors.
2816         continue;
2817       }
2818
2819       case VisitorJob::LambdaExprPartsKind: {
2820         // Visit captures.
2821         const LambdaExpr *E = cast<LambdaExprParts>(&LI)->get();
2822         for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(),
2823                                        CEnd = E->explicit_capture_end();
2824              C != CEnd; ++C) {
2825           // FIXME: Lambda init-captures.
2826           if (!C->capturesVariable())
2827             continue;
2828
2829           if (Visit(MakeCursorVariableRef(C->getCapturedVar(),
2830                                           C->getLocation(),
2831                                           TU)))
2832             return true;
2833         }
2834
2835         // Visit parameters and return type, if present.
2836         if (E->hasExplicitParameters() || E->hasExplicitResultType()) {
2837           TypeLoc TL = E->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
2838           if (E->hasExplicitParameters() && E->hasExplicitResultType()) {
2839             // Visit the whole type.
2840             if (Visit(TL))
2841               return true;
2842           } else if (FunctionProtoTypeLoc Proto =
2843                          TL.getAs<FunctionProtoTypeLoc>()) {
2844             if (E->hasExplicitParameters()) {
2845               // Visit parameters.
2846               for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I)
2847                 if (Visit(MakeCXCursor(Proto.getParam(I), TU)))
2848                   return true;
2849             } else {
2850               // Visit result type.
2851               if (Visit(Proto.getReturnLoc()))
2852                 return true;
2853             }
2854           }
2855         }
2856         break;
2857       }
2858
2859       case VisitorJob::PostChildrenVisitKind:
2860         if (PostChildrenVisitor(Parent, ClientData))
2861           return true;
2862         break;
2863     }
2864   }
2865   return false;
2866 }
2867
2868 bool CursorVisitor::Visit(const Stmt *S) {
2869   VisitorWorkList *WL = nullptr;
2870   if (!WorkListFreeList.empty()) {
2871     WL = WorkListFreeList.back();
2872     WL->clear();
2873     WorkListFreeList.pop_back();
2874   }
2875   else {
2876     WL = new VisitorWorkList();
2877     WorkListCache.push_back(WL);
2878   }
2879   EnqueueWorkList(*WL, S);
2880   bool result = RunVisitorWorkList(*WL);
2881   WorkListFreeList.push_back(WL);
2882   return result;
2883 }
2884
2885 namespace {
2886 typedef SmallVector<SourceRange, 4> RefNamePieces;
2887 RefNamePieces
2888 buildPieces(unsigned NameFlags, bool IsMemberRefExpr,
2889             const DeclarationNameInfo &NI, SourceRange QLoc,
2890             const ASTTemplateArgumentListInfo *TemplateArgs = nullptr) {
2891   const bool WantQualifier = NameFlags & CXNameRange_WantQualifier;
2892   const bool WantTemplateArgs = NameFlags & CXNameRange_WantTemplateArgs;
2893   const bool WantSinglePiece = NameFlags & CXNameRange_WantSinglePiece;
2894
2895   const DeclarationName::NameKind Kind = NI.getName().getNameKind();
2896
2897   RefNamePieces Pieces;
2898
2899   if (WantQualifier && QLoc.isValid())
2900     Pieces.push_back(QLoc);
2901
2902   if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr)
2903     Pieces.push_back(NI.getLoc());
2904
2905   if (WantTemplateArgs && TemplateArgs)
2906     Pieces.push_back(SourceRange(TemplateArgs->LAngleLoc,
2907                                  TemplateArgs->RAngleLoc));
2908
2909   if (Kind == DeclarationName::CXXOperatorName) {
2910     Pieces.push_back(SourceLocation::getFromRawEncoding(
2911                        NI.getInfo().CXXOperatorName.BeginOpNameLoc));
2912     Pieces.push_back(SourceLocation::getFromRawEncoding(
2913                        NI.getInfo().CXXOperatorName.EndOpNameLoc));
2914   }
2915
2916   if (WantSinglePiece) {
2917     SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd());
2918     Pieces.clear();
2919     Pieces.push_back(R);
2920   }
2921
2922   return Pieces;
2923 }
2924 }
2925
2926 //===----------------------------------------------------------------------===//
2927 // Misc. API hooks.
2928 //===----------------------------------------------------------------------===//
2929
2930 static void fatal_error_handler(void *user_data, const std::string& reason,
2931                                 bool gen_crash_diag) {
2932   // Write the result out to stderr avoiding errs() because raw_ostreams can
2933   // call report_fatal_error.
2934   fprintf(stderr, "LIBCLANG FATAL ERROR: %s\n", reason.c_str());
2935   ::abort();
2936 }
2937
2938 namespace {
2939 struct RegisterFatalErrorHandler {
2940   RegisterFatalErrorHandler() {
2941     llvm::install_fatal_error_handler(fatal_error_handler, nullptr);
2942   }
2943 };
2944 }
2945
2946 static llvm::ManagedStatic<RegisterFatalErrorHandler> RegisterFatalErrorHandlerOnce;
2947
2948 extern "C" {
2949 CXIndex clang_createIndex(int excludeDeclarationsFromPCH,
2950                           int displayDiagnostics) {
2951   // We use crash recovery to make some of our APIs more reliable, implicitly
2952   // enable it.
2953   if (!getenv("LIBCLANG_DISABLE_CRASH_RECOVERY"))
2954     llvm::CrashRecoveryContext::Enable();
2955
2956   // Look through the managed static to trigger construction of the managed
2957   // static which registers our fatal error handler. This ensures it is only
2958   // registered once.
2959   (void)*RegisterFatalErrorHandlerOnce;
2960
2961   // Initialize targets for clang module support.
2962   llvm::InitializeAllTargets();
2963   llvm::InitializeAllTargetMCs();
2964   llvm::InitializeAllAsmPrinters();
2965   llvm::InitializeAllAsmParsers();
2966
2967   CIndexer *CIdxr = new CIndexer();
2968
2969   if (excludeDeclarationsFromPCH)
2970     CIdxr->setOnlyLocalDecls();
2971   if (displayDiagnostics)
2972     CIdxr->setDisplayDiagnostics();
2973
2974   if (getenv("LIBCLANG_BGPRIO_INDEX"))
2975     CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() |
2976                                CXGlobalOpt_ThreadBackgroundPriorityForIndexing);
2977   if (getenv("LIBCLANG_BGPRIO_EDIT"))
2978     CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() |
2979                                CXGlobalOpt_ThreadBackgroundPriorityForEditing);
2980
2981   return CIdxr;
2982 }
2983
2984 void clang_disposeIndex(CXIndex CIdx) {
2985   if (CIdx)
2986     delete static_cast<CIndexer *>(CIdx);
2987 }
2988
2989 void clang_CXIndex_setGlobalOptions(CXIndex CIdx, unsigned options) {
2990   if (CIdx)
2991     static_cast<CIndexer *>(CIdx)->setCXGlobalOptFlags(options);
2992 }
2993
2994 unsigned clang_CXIndex_getGlobalOptions(CXIndex CIdx) {
2995   if (CIdx)
2996     return static_cast<CIndexer *>(CIdx)->getCXGlobalOptFlags();
2997   return 0;
2998 }
2999
3000 void clang_toggleCrashRecovery(unsigned isEnabled) {
3001   if (isEnabled)
3002     llvm::CrashRecoveryContext::Enable();
3003   else
3004     llvm::CrashRecoveryContext::Disable();
3005 }
3006
3007 CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx,
3008                                               const char *ast_filename) {
3009   CXTranslationUnit TU;
3010   enum CXErrorCode Result =
3011       clang_createTranslationUnit2(CIdx, ast_filename, &TU);
3012   (void)Result;
3013   assert((TU && Result == CXError_Success) ||
3014          (!TU && Result != CXError_Success));
3015   return TU;
3016 }
3017
3018 enum CXErrorCode clang_createTranslationUnit2(CXIndex CIdx,
3019                                               const char *ast_filename,
3020                                               CXTranslationUnit *out_TU) {
3021   if (out_TU)
3022     *out_TU = nullptr;
3023
3024   if (!CIdx || !ast_filename || !out_TU)
3025     return CXError_InvalidArguments;
3026
3027   LOG_FUNC_SECTION {
3028     *Log << ast_filename;
3029   }
3030
3031   CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
3032   FileSystemOptions FileSystemOpts;
3033
3034   IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
3035       CompilerInstance::createDiagnostics(new DiagnosticOptions());
3036   std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
3037       ast_filename, CXXIdx->getPCHContainerOperations()->getRawReader(), Diags,
3038       FileSystemOpts, /*UseDebugInfo=*/false,
3039       CXXIdx->getOnlyLocalDecls(), None,
3040       /*CaptureDiagnostics=*/true,
3041       /*AllowPCHWithCompilerErrors=*/true,
3042       /*UserFilesAreVolatile=*/true);
3043   *out_TU = MakeCXTranslationUnit(CXXIdx, AU.release());
3044   return *out_TU ? CXError_Success : CXError_Failure;
3045 }
3046
3047 unsigned clang_defaultEditingTranslationUnitOptions() {
3048   return CXTranslationUnit_PrecompiledPreamble |
3049          CXTranslationUnit_CacheCompletionResults;
3050 }
3051
3052 CXTranslationUnit
3053 clang_createTranslationUnitFromSourceFile(CXIndex CIdx,
3054                                           const char *source_filename,
3055                                           int num_command_line_args,
3056                                           const char * const *command_line_args,
3057                                           unsigned num_unsaved_files,
3058                                           struct CXUnsavedFile *unsaved_files) {
3059   unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord;
3060   return clang_parseTranslationUnit(CIdx, source_filename,
3061                                     command_line_args, num_command_line_args,
3062                                     unsaved_files, num_unsaved_files,
3063                                     Options);
3064 }
3065
3066 static CXErrorCode
3067 clang_parseTranslationUnit_Impl(CXIndex CIdx, const char *source_filename,
3068                                 const char *const *command_line_args,
3069                                 int num_command_line_args,
3070                                 ArrayRef<CXUnsavedFile> unsaved_files,
3071                                 unsigned options, CXTranslationUnit *out_TU) {
3072   // Set up the initial return values.
3073   if (out_TU)
3074     *out_TU = nullptr;
3075
3076   // Check arguments.
3077   if (!CIdx || !out_TU)
3078     return CXError_InvalidArguments;
3079
3080   CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
3081
3082   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
3083     setThreadBackgroundPriority();
3084
3085   bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble;
3086   bool CreatePreambleOnFirstParse =
3087       options & CXTranslationUnit_CreatePreambleOnFirstParse;
3088   // FIXME: Add a flag for modules.
3089   TranslationUnitKind TUKind
3090     = (options & CXTranslationUnit_Incomplete)? TU_Prefix : TU_Complete;
3091   bool CacheCodeCompletionResults
3092     = options & CXTranslationUnit_CacheCompletionResults;
3093   bool IncludeBriefCommentsInCodeCompletion
3094     = options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion;
3095   bool SkipFunctionBodies = options & CXTranslationUnit_SkipFunctionBodies;
3096   bool ForSerialization = options & CXTranslationUnit_ForSerialization;
3097
3098   // Configure the diagnostics.
3099   IntrusiveRefCntPtr<DiagnosticsEngine>
3100     Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions));
3101
3102   // Recover resources if we crash before exiting this function.
3103   llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
3104     llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
3105     DiagCleanup(Diags.get());
3106
3107   std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles(
3108       new std::vector<ASTUnit::RemappedFile>());
3109
3110   // Recover resources if we crash before exiting this function.
3111   llvm::CrashRecoveryContextCleanupRegistrar<
3112     std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
3113
3114   for (auto &UF : unsaved_files) {
3115     std::unique_ptr<llvm::MemoryBuffer> MB =
3116         llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
3117     RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
3118   }
3119
3120   std::unique_ptr<std::vector<const char *>> Args(
3121       new std::vector<const char *>());
3122
3123   // Recover resources if we crash before exiting this method.
3124   llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> >
3125     ArgsCleanup(Args.get());
3126
3127   // Since the Clang C library is primarily used by batch tools dealing with
3128   // (often very broken) source code, where spell-checking can have a
3129   // significant negative impact on performance (particularly when
3130   // precompiled headers are involved), we disable it by default.
3131   // Only do this if we haven't found a spell-checking-related argument.
3132   bool FoundSpellCheckingArgument = false;
3133   for (int I = 0; I != num_command_line_args; ++I) {
3134     if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 ||
3135         strcmp(command_line_args[I], "-fspell-checking") == 0) {
3136       FoundSpellCheckingArgument = true;
3137       break;
3138     }
3139   }
3140   Args->insert(Args->end(), command_line_args,
3141                command_line_args + num_command_line_args);
3142
3143   if (!FoundSpellCheckingArgument)
3144     Args->insert(Args->begin() + 1, "-fno-spell-checking");
3145
3146   // The 'source_filename' argument is optional.  If the caller does not
3147   // specify it then it is assumed that the source file is specified
3148   // in the actual argument list.
3149   // Put the source file after command_line_args otherwise if '-x' flag is
3150   // present it will be unused.
3151   if (source_filename)
3152     Args->push_back(source_filename);
3153
3154   // Do we need the detailed preprocessing record?
3155   if (options & CXTranslationUnit_DetailedPreprocessingRecord) {
3156     Args->push_back("-Xclang");
3157     Args->push_back("-detailed-preprocessing-record");
3158   }
3159
3160   unsigned NumErrors = Diags->getClient()->getNumErrors();
3161   std::unique_ptr<ASTUnit> ErrUnit;
3162   // Unless the user specified that they want the preamble on the first parse
3163   // set it up to be created on the first reparse. This makes the first parse
3164   // faster, trading for a slower (first) reparse.
3165   unsigned PrecompilePreambleAfterNParses =
3166       !PrecompilePreamble ? 0 : 2 - CreatePreambleOnFirstParse;
3167   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine(
3168       Args->data(), Args->data() + Args->size(),
3169       CXXIdx->getPCHContainerOperations(), Diags,
3170       CXXIdx->getClangResourcesPath(), CXXIdx->getOnlyLocalDecls(),
3171       /*CaptureDiagnostics=*/true, *RemappedFiles.get(),
3172       /*RemappedFilesKeepOriginalName=*/true, PrecompilePreambleAfterNParses,
3173       TUKind, CacheCodeCompletionResults, IncludeBriefCommentsInCodeCompletion,
3174       /*AllowPCHWithCompilerErrors=*/true, SkipFunctionBodies,
3175       /*UserFilesAreVolatile=*/true, ForSerialization,
3176       CXXIdx->getPCHContainerOperations()->getRawReader().getFormat(),
3177       &ErrUnit));
3178
3179   // Early failures in LoadFromCommandLine may return with ErrUnit unset.
3180   if (!Unit && !ErrUnit)
3181     return CXError_ASTReadError;
3182
3183   if (NumErrors != Diags->getClient()->getNumErrors()) {
3184     // Make sure to check that 'Unit' is non-NULL.
3185     if (CXXIdx->getDisplayDiagnostics())
3186       printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get());
3187   }
3188
3189   if (isASTReadError(Unit ? Unit.get() : ErrUnit.get()))
3190     return CXError_ASTReadError;
3191
3192   *out_TU = MakeCXTranslationUnit(CXXIdx, Unit.release());
3193   return *out_TU ? CXError_Success : CXError_Failure;
3194 }
3195
3196 CXTranslationUnit
3197 clang_parseTranslationUnit(CXIndex CIdx,
3198                            const char *source_filename,
3199                            const char *const *command_line_args,
3200                            int num_command_line_args,
3201                            struct CXUnsavedFile *unsaved_files,
3202                            unsigned num_unsaved_files,
3203                            unsigned options) {
3204   CXTranslationUnit TU;
3205   enum CXErrorCode Result = clang_parseTranslationUnit2(
3206       CIdx, source_filename, command_line_args, num_command_line_args,
3207       unsaved_files, num_unsaved_files, options, &TU);
3208   (void)Result;
3209   assert((TU && Result == CXError_Success) ||
3210          (!TU && Result != CXError_Success));
3211   return TU;
3212 }
3213
3214 enum CXErrorCode clang_parseTranslationUnit2(
3215     CXIndex CIdx, const char *source_filename,
3216     const char *const *command_line_args, int num_command_line_args,
3217     struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files,
3218     unsigned options, CXTranslationUnit *out_TU) {
3219   SmallVector<const char *, 4> Args;
3220   Args.push_back("clang");
3221   Args.append(command_line_args, command_line_args + num_command_line_args);
3222   return clang_parseTranslationUnit2FullArgv(
3223       CIdx, source_filename, Args.data(), Args.size(), unsaved_files,
3224       num_unsaved_files, options, out_TU);
3225 }
3226
3227 enum CXErrorCode clang_parseTranslationUnit2FullArgv(
3228     CXIndex CIdx, const char *source_filename,
3229     const char *const *command_line_args, int num_command_line_args,
3230     struct CXUnsavedFile *unsaved_files, unsigned num_unsaved_files,
3231     unsigned options, CXTranslationUnit *out_TU) {
3232   LOG_FUNC_SECTION {
3233     *Log << source_filename << ": ";
3234     for (int i = 0; i != num_command_line_args; ++i)
3235       *Log << command_line_args[i] << " ";
3236   }
3237
3238   if (num_unsaved_files && !unsaved_files)
3239     return CXError_InvalidArguments;
3240
3241   CXErrorCode result = CXError_Failure;
3242   auto ParseTranslationUnitImpl = [=, &result] {
3243     result = clang_parseTranslationUnit_Impl(
3244         CIdx, source_filename, command_line_args, num_command_line_args,
3245         llvm::makeArrayRef(unsaved_files, num_unsaved_files), options, out_TU);
3246   };
3247   llvm::CrashRecoveryContext CRC;
3248
3249   if (!RunSafely(CRC, ParseTranslationUnitImpl)) {
3250     fprintf(stderr, "libclang: crash detected during parsing: {\n");
3251     fprintf(stderr, "  'source_filename' : '%s'\n", source_filename);
3252     fprintf(stderr, "  'command_line_args' : [");
3253     for (int i = 0; i != num_command_line_args; ++i) {
3254       if (i)
3255         fprintf(stderr, ", ");
3256       fprintf(stderr, "'%s'", command_line_args[i]);
3257     }
3258     fprintf(stderr, "],\n");
3259     fprintf(stderr, "  'unsaved_files' : [");
3260     for (unsigned i = 0; i != num_unsaved_files; ++i) {
3261       if (i)
3262         fprintf(stderr, ", ");
3263       fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename,
3264               unsaved_files[i].Length);
3265     }
3266     fprintf(stderr, "],\n");
3267     fprintf(stderr, "  'options' : %d,\n", options);
3268     fprintf(stderr, "}\n");
3269
3270     return CXError_Crashed;
3271   } else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
3272     if (CXTranslationUnit *TU = out_TU)
3273       PrintLibclangResourceUsage(*TU);
3274   }
3275
3276   return result;
3277 }
3278
3279 unsigned clang_defaultSaveOptions(CXTranslationUnit TU) {
3280   return CXSaveTranslationUnit_None;
3281 }
3282
3283 static CXSaveError clang_saveTranslationUnit_Impl(CXTranslationUnit TU,
3284                                                   const char *FileName,
3285                                                   unsigned options) {
3286   CIndexer *CXXIdx = TU->CIdx;
3287   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing))
3288     setThreadBackgroundPriority();
3289
3290   bool hadError = cxtu::getASTUnit(TU)->Save(FileName);
3291   return hadError ? CXSaveError_Unknown : CXSaveError_None;
3292 }
3293
3294 int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName,
3295                               unsigned options) {
3296   LOG_FUNC_SECTION {
3297     *Log << TU << ' ' << FileName;
3298   }
3299
3300   if (isNotUsableTU(TU)) {
3301     LOG_BAD_TU(TU);
3302     return CXSaveError_InvalidTU;
3303   }
3304
3305   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
3306   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
3307   if (!CXXUnit->hasSema())
3308     return CXSaveError_InvalidTU;
3309
3310   CXSaveError result;
3311   auto SaveTranslationUnitImpl = [=, &result]() {
3312     result = clang_saveTranslationUnit_Impl(TU, FileName, options);
3313   };
3314
3315   if (!CXXUnit->getDiagnostics().hasUnrecoverableErrorOccurred() ||
3316       getenv("LIBCLANG_NOTHREADS")) {
3317     SaveTranslationUnitImpl();
3318
3319     if (getenv("LIBCLANG_RESOURCE_USAGE"))
3320       PrintLibclangResourceUsage(TU);
3321
3322     return result;
3323   }
3324
3325   // We have an AST that has invalid nodes due to compiler errors.
3326   // Use a crash recovery thread for protection.
3327
3328   llvm::CrashRecoveryContext CRC;
3329
3330   if (!RunSafely(CRC, SaveTranslationUnitImpl)) {
3331     fprintf(stderr, "libclang: crash detected during AST saving: {\n");
3332     fprintf(stderr, "  'filename' : '%s'\n", FileName);
3333     fprintf(stderr, "  'options' : %d,\n", options);
3334     fprintf(stderr, "}\n");
3335
3336     return CXSaveError_Unknown;
3337
3338   } else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
3339     PrintLibclangResourceUsage(TU);
3340   }
3341
3342   return result;
3343 }
3344
3345 void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) {
3346   if (CTUnit) {
3347     // If the translation unit has been marked as unsafe to free, just discard
3348     // it.
3349     ASTUnit *Unit = cxtu::getASTUnit(CTUnit);
3350     if (Unit && Unit->isUnsafeToFree())
3351       return;
3352
3353     delete cxtu::getASTUnit(CTUnit);
3354     delete CTUnit->StringPool;
3355     delete static_cast<CXDiagnosticSetImpl *>(CTUnit->Diagnostics);
3356     disposeOverridenCXCursorsPool(CTUnit->OverridenCursorsPool);
3357     delete CTUnit->CommentToXML;
3358     delete CTUnit;
3359   }
3360 }
3361
3362 unsigned clang_defaultReparseOptions(CXTranslationUnit TU) {
3363   return CXReparse_None;
3364 }
3365
3366 static CXErrorCode
3367 clang_reparseTranslationUnit_Impl(CXTranslationUnit TU,
3368                                   ArrayRef<CXUnsavedFile> unsaved_files,
3369                                   unsigned options) {
3370   // Check arguments.
3371   if (isNotUsableTU(TU)) {
3372     LOG_BAD_TU(TU);
3373     return CXError_InvalidArguments;
3374   }
3375
3376   // Reset the associated diagnostics.
3377   delete static_cast<CXDiagnosticSetImpl*>(TU->Diagnostics);
3378   TU->Diagnostics = nullptr;
3379
3380   CIndexer *CXXIdx = TU->CIdx;
3381   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
3382     setThreadBackgroundPriority();
3383
3384   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
3385   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
3386
3387   std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles(
3388       new std::vector<ASTUnit::RemappedFile>());
3389
3390   // Recover resources if we crash before exiting this function.
3391   llvm::CrashRecoveryContextCleanupRegistrar<
3392     std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
3393
3394   for (auto &UF : unsaved_files) {
3395     std::unique_ptr<llvm::MemoryBuffer> MB =
3396         llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
3397     RemappedFiles->push_back(std::make_pair(UF.Filename, MB.release()));
3398   }
3399
3400   if (!CXXUnit->Reparse(CXXIdx->getPCHContainerOperations(),
3401                         *RemappedFiles.get()))
3402     return CXError_Success;
3403   if (isASTReadError(CXXUnit))
3404     return CXError_ASTReadError;
3405   return CXError_Failure;
3406 }
3407
3408 int clang_reparseTranslationUnit(CXTranslationUnit TU,
3409                                  unsigned num_unsaved_files,
3410                                  struct CXUnsavedFile *unsaved_files,
3411                                  unsigned options) {
3412   LOG_FUNC_SECTION {
3413     *Log << TU;
3414   }
3415
3416   if (num_unsaved_files && !unsaved_files)
3417     return CXError_InvalidArguments;
3418
3419   CXErrorCode result;
3420   auto ReparseTranslationUnitImpl = [=, &result]() {
3421     result = clang_reparseTranslationUnit_Impl(
3422         TU, llvm::makeArrayRef(unsaved_files, num_unsaved_files), options);
3423   };
3424
3425   if (getenv("LIBCLANG_NOTHREADS")) {
3426     ReparseTranslationUnitImpl();
3427     return result;
3428   }
3429
3430   llvm::CrashRecoveryContext CRC;
3431
3432   if (!RunSafely(CRC, ReparseTranslationUnitImpl)) {
3433     fprintf(stderr, "libclang: crash detected during reparsing\n");
3434     cxtu::getASTUnit(TU)->setUnsafeToFree(true);
3435     return CXError_Crashed;
3436   } else if (getenv("LIBCLANG_RESOURCE_USAGE"))
3437     PrintLibclangResourceUsage(TU);
3438
3439   return result;
3440 }
3441
3442
3443 CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) {
3444   if (isNotUsableTU(CTUnit)) {
3445     LOG_BAD_TU(CTUnit);
3446     return cxstring::createEmpty();
3447   }
3448
3449   ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
3450   return cxstring::createDup(CXXUnit->getOriginalSourceFileName());
3451 }
3452
3453 CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) {
3454   if (isNotUsableTU(TU)) {
3455     LOG_BAD_TU(TU);
3456     return clang_getNullCursor();
3457   }
3458
3459   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
3460   return MakeCXCursor(CXXUnit->getASTContext().getTranslationUnitDecl(), TU);
3461 }
3462
3463 } // end: extern "C"
3464
3465 //===----------------------------------------------------------------------===//
3466 // CXFile Operations.
3467 //===----------------------------------------------------------------------===//
3468
3469 extern "C" {
3470 CXString clang_getFileName(CXFile SFile) {
3471   if (!SFile)
3472     return cxstring::createNull();
3473
3474   FileEntry *FEnt = static_cast<FileEntry *>(SFile);
3475   return cxstring::createRef(FEnt->getName());
3476 }
3477
3478 time_t clang_getFileTime(CXFile SFile) {
3479   if (!SFile)
3480     return 0;
3481
3482   FileEntry *FEnt = static_cast<FileEntry *>(SFile);
3483   return FEnt->getModificationTime();
3484 }
3485
3486 CXFile clang_getFile(CXTranslationUnit TU, const char *file_name) {
3487   if (isNotUsableTU(TU)) {
3488     LOG_BAD_TU(TU);
3489     return nullptr;
3490   }
3491
3492   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
3493
3494   FileManager &FMgr = CXXUnit->getFileManager();
3495   return const_cast<FileEntry *>(FMgr.getFile(file_name));
3496 }
3497
3498 unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit TU,
3499                                             CXFile file) {
3500   if (isNotUsableTU(TU)) {
3501     LOG_BAD_TU(TU);
3502     return 0;
3503   }
3504
3505   if (!file)
3506     return 0;
3507
3508   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
3509   FileEntry *FEnt = static_cast<FileEntry *>(file);
3510   return CXXUnit->getPreprocessor().getHeaderSearchInfo()
3511                                           .isFileMultipleIncludeGuarded(FEnt);
3512 }
3513
3514 int clang_getFileUniqueID(CXFile file, CXFileUniqueID *outID) {
3515   if (!file || !outID)
3516     return 1;
3517
3518   FileEntry *FEnt = static_cast<FileEntry *>(file);
3519   const llvm::sys::fs::UniqueID &ID = FEnt->getUniqueID();
3520   outID->data[0] = ID.getDevice();
3521   outID->data[1] = ID.getFile();
3522   outID->data[2] = FEnt->getModificationTime();
3523   return 0;
3524 }
3525
3526 int clang_File_isEqual(CXFile file1, CXFile file2) {
3527   if (file1 == file2)
3528     return true;
3529
3530   if (!file1 || !file2)
3531     return false;
3532
3533   FileEntry *FEnt1 = static_cast<FileEntry *>(file1);
3534   FileEntry *FEnt2 = static_cast<FileEntry *>(file2);
3535   return FEnt1->getUniqueID() == FEnt2->getUniqueID();
3536 }
3537
3538 } // end: extern "C"
3539
3540 //===----------------------------------------------------------------------===//
3541 // CXCursor Operations.
3542 //===----------------------------------------------------------------------===//
3543
3544 static const Decl *getDeclFromExpr(const Stmt *E) {
3545   if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
3546     return getDeclFromExpr(CE->getSubExpr());
3547
3548   if (const DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E))
3549     return RefExpr->getDecl();
3550   if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
3551     return ME->getMemberDecl();
3552   if (const ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E))
3553     return RE->getDecl();
3554   if (const ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E)) {
3555     if (PRE->isExplicitProperty())
3556       return PRE->getExplicitProperty();
3557     // It could be messaging both getter and setter as in:
3558     // ++myobj.myprop;
3559     // in which case prefer to associate the setter since it is less obvious
3560     // from inspecting the source that the setter is going to get called.
3561     if (PRE->isMessagingSetter())
3562       return PRE->getImplicitPropertySetter();
3563     return PRE->getImplicitPropertyGetter();
3564   }
3565   if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
3566     return getDeclFromExpr(POE->getSyntacticForm());
3567   if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E))
3568     if (Expr *Src = OVE->getSourceExpr())
3569       return getDeclFromExpr(Src);
3570
3571   if (const CallExpr *CE = dyn_cast<CallExpr>(E))
3572     return getDeclFromExpr(CE->getCallee());
3573   if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E))
3574     if (!CE->isElidable())
3575     return CE->getConstructor();
3576   if (const ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E))
3577     return OME->getMethodDecl();
3578
3579   if (const ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E))
3580     return PE->getProtocol();
3581   if (const SubstNonTypeTemplateParmPackExpr *NTTP
3582                               = dyn_cast<SubstNonTypeTemplateParmPackExpr>(E))
3583     return NTTP->getParameterPack();
3584   if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
3585     if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) ||
3586         isa<ParmVarDecl>(SizeOfPack->getPack()))
3587       return SizeOfPack->getPack();
3588
3589   return nullptr;
3590 }
3591
3592 static SourceLocation getLocationFromExpr(const Expr *E) {
3593   if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
3594     return getLocationFromExpr(CE->getSubExpr());
3595
3596   if (const ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E))
3597     return /*FIXME:*/Msg->getLeftLoc();
3598   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
3599     return DRE->getLocation();
3600   if (const MemberExpr *Member = dyn_cast<MemberExpr>(E))
3601     return Member->getMemberLoc();
3602   if (const ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E))
3603     return Ivar->getLocation();
3604   if (const SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
3605     return SizeOfPack->getPackLoc();
3606   if (const ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E))
3607     return PropRef->getLocation();
3608
3609   return E->getLocStart();
3610 }
3611
3612 static std::string getMangledStructor(std::unique_ptr<MangleContext> &M,
3613                                       std::unique_ptr<llvm::DataLayout> &DL,
3614                                       const NamedDecl *ND,
3615                                       unsigned StructorType) {
3616   std::string FrontendBuf;
3617   llvm::raw_string_ostream FOS(FrontendBuf);
3618
3619   if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND))
3620     M->mangleCXXCtor(CD, static_cast<CXXCtorType>(StructorType), FOS);
3621   else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND))
3622     M->mangleCXXDtor(DD, static_cast<CXXDtorType>(StructorType), FOS);
3623
3624   std::string BackendBuf;
3625   llvm::raw_string_ostream BOS(BackendBuf);
3626
3627   llvm::Mangler::getNameWithPrefix(BOS, llvm::Twine(FOS.str()), *DL);
3628
3629   return BOS.str();
3630 }
3631
3632 extern "C" {
3633
3634 unsigned clang_visitChildren(CXCursor parent,
3635                              CXCursorVisitor visitor,
3636                              CXClientData client_data) {
3637   CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data,
3638                           /*VisitPreprocessorLast=*/false);
3639   return CursorVis.VisitChildren(parent);
3640 }
3641
3642 #ifndef __has_feature
3643 #define __has_feature(x) 0
3644 #endif
3645 #if __has_feature(blocks)
3646 typedef enum CXChildVisitResult
3647      (^CXCursorVisitorBlock)(CXCursor cursor, CXCursor parent);
3648
3649 static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
3650     CXClientData client_data) {
3651   CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
3652   return block(cursor, parent);
3653 }
3654 #else
3655 // If we are compiled with a compiler that doesn't have native blocks support,
3656 // define and call the block manually, so the
3657 typedef struct _CXChildVisitResult
3658 {
3659         void *isa;
3660         int flags;
3661         int reserved;
3662         enum CXChildVisitResult(*invoke)(struct _CXChildVisitResult*, CXCursor,
3663                                          CXCursor);
3664 } *CXCursorVisitorBlock;
3665
3666 static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
3667     CXClientData client_data) {
3668   CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
3669   return block->invoke(block, cursor, parent);
3670 }
3671 #endif
3672
3673
3674 unsigned clang_visitChildrenWithBlock(CXCursor parent,
3675                                       CXCursorVisitorBlock block) {
3676   return clang_visitChildren(parent, visitWithBlock, block);
3677 }
3678
3679 static CXString getDeclSpelling(const Decl *D) {
3680   if (!D)
3681     return cxstring::createEmpty();
3682
3683   const NamedDecl *ND = dyn_cast<NamedDecl>(D);
3684   if (!ND) {
3685     if (const ObjCPropertyImplDecl *PropImpl =
3686             dyn_cast<ObjCPropertyImplDecl>(D))
3687       if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
3688         return cxstring::createDup(Property->getIdentifier()->getName());
3689
3690     if (const ImportDecl *ImportD = dyn_cast<ImportDecl>(D))
3691       if (Module *Mod = ImportD->getImportedModule())
3692         return cxstring::createDup(Mod->getFullModuleName());
3693
3694     return cxstring::createEmpty();
3695   }
3696
3697   if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
3698     return cxstring::createDup(OMD->getSelector().getAsString());
3699
3700   if (const ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND))
3701     // No, this isn't the same as the code below. getIdentifier() is non-virtual
3702     // and returns different names. NamedDecl returns the class name and
3703     // ObjCCategoryImplDecl returns the category name.
3704     return cxstring::createRef(CIMP->getIdentifier()->getNameStart());
3705
3706   if (isa<UsingDirectiveDecl>(D))
3707     return cxstring::createEmpty();
3708
3709   SmallString<1024> S;
3710   llvm::raw_svector_ostream os(S);
3711   ND->printName(os);
3712
3713   return cxstring::createDup(os.str());
3714 }
3715
3716 CXString clang_getCursorSpelling(CXCursor C) {
3717   if (clang_isTranslationUnit(C.kind))
3718     return clang_getTranslationUnitSpelling(getCursorTU(C));
3719
3720   if (clang_isReference(C.kind)) {
3721     switch (C.kind) {
3722     case CXCursor_ObjCSuperClassRef: {
3723       const ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first;
3724       return cxstring::createRef(Super->getIdentifier()->getNameStart());
3725     }
3726     case CXCursor_ObjCClassRef: {
3727       const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
3728       return cxstring::createRef(Class->getIdentifier()->getNameStart());
3729     }
3730     case CXCursor_ObjCProtocolRef: {
3731       const ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first;
3732       assert(OID && "getCursorSpelling(): Missing protocol decl");
3733       return cxstring::createRef(OID->getIdentifier()->getNameStart());
3734     }
3735     case CXCursor_CXXBaseSpecifier: {
3736       const CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C);
3737       return cxstring::createDup(B->getType().getAsString());
3738     }
3739     case CXCursor_TypeRef: {
3740       const TypeDecl *Type = getCursorTypeRef(C).first;
3741       assert(Type && "Missing type decl");
3742
3743       return cxstring::createDup(getCursorContext(C).getTypeDeclType(Type).
3744                               getAsString());
3745     }
3746     case CXCursor_TemplateRef: {
3747       const TemplateDecl *Template = getCursorTemplateRef(C).first;
3748       assert(Template && "Missing template decl");
3749
3750       return cxstring::createDup(Template->getNameAsString());
3751     }
3752
3753     case CXCursor_NamespaceRef: {
3754       const NamedDecl *NS = getCursorNamespaceRef(C).first;
3755       assert(NS && "Missing namespace decl");
3756
3757       return cxstring::createDup(NS->getNameAsString());
3758     }
3759
3760     case CXCursor_MemberRef: {
3761       const FieldDecl *Field = getCursorMemberRef(C).first;
3762       assert(Field && "Missing member decl");
3763
3764       return cxstring::createDup(Field->getNameAsString());
3765     }
3766
3767     case CXCursor_LabelRef: {
3768       const LabelStmt *Label = getCursorLabelRef(C).first;
3769       assert(Label && "Missing label");
3770
3771       return cxstring::createRef(Label->getName());
3772     }
3773
3774     case CXCursor_OverloadedDeclRef: {
3775       OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
3776       if (const Decl *D = Storage.dyn_cast<const Decl *>()) {
3777         if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
3778           return cxstring::createDup(ND->getNameAsString());
3779         return cxstring::createEmpty();
3780       }
3781       if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
3782         return cxstring::createDup(E->getName().getAsString());
3783       OverloadedTemplateStorage *Ovl
3784         = Storage.get<OverloadedTemplateStorage*>();
3785       if (Ovl->size() == 0)
3786         return cxstring::createEmpty();
3787       return cxstring::createDup((*Ovl->begin())->getNameAsString());
3788     }
3789
3790     case CXCursor_VariableRef: {
3791       const VarDecl *Var = getCursorVariableRef(C).first;
3792       assert(Var && "Missing variable decl");
3793
3794       return cxstring::createDup(Var->getNameAsString());
3795     }
3796
3797     default:
3798       return cxstring::createRef("<not implemented>");
3799     }
3800   }
3801
3802   if (clang_isExpression(C.kind)) {
3803     const Expr *E = getCursorExpr(C);
3804
3805     if (C.kind == CXCursor_ObjCStringLiteral ||
3806         C.kind == CXCursor_StringLiteral) {
3807       const StringLiteral *SLit;
3808       if (const ObjCStringLiteral *OSL = dyn_cast<ObjCStringLiteral>(E)) {
3809         SLit = OSL->getString();
3810       } else {
3811         SLit = cast<StringLiteral>(E);
3812       }
3813       SmallString<256> Buf;
3814       llvm::raw_svector_ostream OS(Buf);
3815       SLit->outputString(OS);
3816       return cxstring::createDup(OS.str());
3817     }
3818
3819     const Decl *D = getDeclFromExpr(getCursorExpr(C));
3820     if (D)
3821       return getDeclSpelling(D);
3822     return cxstring::createEmpty();
3823   }
3824
3825   if (clang_isStatement(C.kind)) {
3826     const Stmt *S = getCursorStmt(C);
3827     if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
3828       return cxstring::createRef(Label->getName());
3829
3830     return cxstring::createEmpty();
3831   }
3832
3833   if (C.kind == CXCursor_MacroExpansion)
3834     return cxstring::createRef(getCursorMacroExpansion(C).getName()
3835                                                            ->getNameStart());
3836
3837   if (C.kind == CXCursor_MacroDefinition)
3838     return cxstring::createRef(getCursorMacroDefinition(C)->getName()
3839                                                            ->getNameStart());
3840
3841   if (C.kind == CXCursor_InclusionDirective)
3842     return cxstring::createDup(getCursorInclusionDirective(C)->getFileName());
3843
3844   if (clang_isDeclaration(C.kind))
3845     return getDeclSpelling(getCursorDecl(C));
3846
3847   if (C.kind == CXCursor_AnnotateAttr) {
3848     const AnnotateAttr *AA = cast<AnnotateAttr>(cxcursor::getCursorAttr(C));
3849     return cxstring::createDup(AA->getAnnotation());
3850   }
3851
3852   if (C.kind == CXCursor_AsmLabelAttr) {
3853     const AsmLabelAttr *AA = cast<AsmLabelAttr>(cxcursor::getCursorAttr(C));
3854     return cxstring::createDup(AA->getLabel());
3855   }
3856
3857   if (C.kind == CXCursor_PackedAttr) {
3858     return cxstring::createRef("packed");
3859   }
3860
3861   if (C.kind == CXCursor_VisibilityAttr) {
3862     const VisibilityAttr *AA = cast<VisibilityAttr>(cxcursor::getCursorAttr(C));
3863     switch (AA->getVisibility()) {
3864     case VisibilityAttr::VisibilityType::Default:
3865       return cxstring::createRef("default");
3866     case VisibilityAttr::VisibilityType::Hidden:
3867       return cxstring::createRef("hidden");
3868     case VisibilityAttr::VisibilityType::Protected:
3869       return cxstring::createRef("protected");
3870     }
3871     llvm_unreachable("unknown visibility type");
3872   }
3873
3874   return cxstring::createEmpty();
3875 }
3876
3877 CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C,
3878                                                 unsigned pieceIndex,
3879                                                 unsigned options) {
3880   if (clang_Cursor_isNull(C))
3881     return clang_getNullRange();
3882
3883   ASTContext &Ctx = getCursorContext(C);
3884
3885   if (clang_isStatement(C.kind)) {
3886     const Stmt *S = getCursorStmt(C);
3887     if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) {
3888       if (pieceIndex > 0)
3889         return clang_getNullRange();
3890       return cxloc::translateSourceRange(Ctx, Label->getIdentLoc());
3891     }
3892
3893     return clang_getNullRange();
3894   }
3895
3896   if (C.kind == CXCursor_ObjCMessageExpr) {
3897     if (const ObjCMessageExpr *
3898           ME = dyn_cast_or_null<ObjCMessageExpr>(getCursorExpr(C))) {
3899       if (pieceIndex >= ME->getNumSelectorLocs())
3900         return clang_getNullRange();
3901       return cxloc::translateSourceRange(Ctx, ME->getSelectorLoc(pieceIndex));
3902     }
3903   }
3904
3905   if (C.kind == CXCursor_ObjCInstanceMethodDecl ||
3906       C.kind == CXCursor_ObjCClassMethodDecl) {
3907     if (const ObjCMethodDecl *
3908           MD = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(C))) {
3909       if (pieceIndex >= MD->getNumSelectorLocs())
3910         return clang_getNullRange();
3911       return cxloc::translateSourceRange(Ctx, MD->getSelectorLoc(pieceIndex));
3912     }
3913   }
3914
3915   if (C.kind == CXCursor_ObjCCategoryDecl ||
3916       C.kind == CXCursor_ObjCCategoryImplDecl) {
3917     if (pieceIndex > 0)
3918       return clang_getNullRange();
3919     if (const ObjCCategoryDecl *
3920           CD = dyn_cast_or_null<ObjCCategoryDecl>(getCursorDecl(C)))
3921       return cxloc::translateSourceRange(Ctx, CD->getCategoryNameLoc());
3922     if (const ObjCCategoryImplDecl *
3923           CID = dyn_cast_or_null<ObjCCategoryImplDecl>(getCursorDecl(C)))
3924       return cxloc::translateSourceRange(Ctx, CID->getCategoryNameLoc());
3925   }
3926
3927   if (C.kind == CXCursor_ModuleImportDecl) {
3928     if (pieceIndex > 0)
3929       return clang_getNullRange();
3930     if (const ImportDecl *ImportD =
3931             dyn_cast_or_null<ImportDecl>(getCursorDecl(C))) {
3932       ArrayRef<SourceLocation> Locs = ImportD->getIdentifierLocs();
3933       if (!Locs.empty())
3934         return cxloc::translateSourceRange(Ctx,
3935                                          SourceRange(Locs.front(), Locs.back()));
3936     }
3937     return clang_getNullRange();
3938   }
3939
3940   if (C.kind == CXCursor_CXXMethod || C.kind == CXCursor_Destructor ||
3941       C.kind == CXCursor_ConversionFunction) {
3942     if (pieceIndex > 0)
3943       return clang_getNullRange();
3944     if (const FunctionDecl *FD =
3945             dyn_cast_or_null<FunctionDecl>(getCursorDecl(C))) {
3946       DeclarationNameInfo FunctionName = FD->getNameInfo();
3947       return cxloc::translateSourceRange(Ctx, FunctionName.getSourceRange());
3948     }
3949     return clang_getNullRange();
3950   }
3951
3952   // FIXME: A CXCursor_InclusionDirective should give the location of the
3953   // filename, but we don't keep track of this.
3954
3955   // FIXME: A CXCursor_AnnotateAttr should give the location of the annotation
3956   // but we don't keep track of this.
3957
3958   // FIXME: A CXCursor_AsmLabelAttr should give the location of the label
3959   // but we don't keep track of this.
3960
3961   // Default handling, give the location of the cursor.
3962
3963   if (pieceIndex > 0)
3964     return clang_getNullRange();
3965
3966   CXSourceLocation CXLoc = clang_getCursorLocation(C);
3967   SourceLocation Loc = cxloc::translateSourceLocation(CXLoc);
3968   return cxloc::translateSourceRange(Ctx, Loc);
3969 }
3970
3971 CXString clang_Cursor_getMangling(CXCursor C) {
3972   if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind))
3973     return cxstring::createEmpty();
3974
3975   // Mangling only works for functions and variables.
3976   const Decl *D = getCursorDecl(C);
3977   if (!D || !(isa<FunctionDecl>(D) || isa<VarDecl>(D)))
3978     return cxstring::createEmpty();
3979
3980   // First apply frontend mangling.
3981   const NamedDecl *ND = cast<NamedDecl>(D);
3982   ASTContext &Ctx = ND->getASTContext();
3983   std::unique_ptr<MangleContext> MC(Ctx.createMangleContext());
3984
3985   std::string FrontendBuf;
3986   llvm::raw_string_ostream FrontendBufOS(FrontendBuf);
3987   if (MC->shouldMangleDeclName(ND)) {
3988     MC->mangleName(ND, FrontendBufOS);
3989   } else {
3990     ND->printName(FrontendBufOS);
3991   }
3992
3993   // Now apply backend mangling.
3994   std::unique_ptr<llvm::DataLayout> DL(
3995       new llvm::DataLayout(Ctx.getTargetInfo().getDataLayoutString()));
3996
3997   std::string FinalBuf;
3998   llvm::raw_string_ostream FinalBufOS(FinalBuf);
3999   llvm::Mangler::getNameWithPrefix(FinalBufOS, llvm::Twine(FrontendBufOS.str()),
4000                                    *DL);
4001
4002   return cxstring::createDup(FinalBufOS.str());
4003 }
4004
4005 CXStringSet *clang_Cursor_getCXXManglings(CXCursor C) {
4006   if (clang_isInvalid(C.kind) || !clang_isDeclaration(C.kind))
4007     return nullptr;
4008
4009   const Decl *D = getCursorDecl(C);
4010   if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D)))
4011     return nullptr;
4012
4013   const NamedDecl *ND = cast<NamedDecl>(D);
4014
4015   ASTContext &Ctx = ND->getASTContext();
4016   std::unique_ptr<MangleContext> M(Ctx.createMangleContext());
4017   std::unique_ptr<llvm::DataLayout> DL(
4018       new llvm::DataLayout(Ctx.getTargetInfo().getDataLayoutString()));
4019
4020   std::vector<std::string> Manglings;
4021
4022   auto hasDefaultCXXMethodCC = [](ASTContext &C, const CXXMethodDecl *MD) {
4023     auto DefaultCC = C.getDefaultCallingConvention(/*IsVariadic=*/false,
4024                                                    /*IsCSSMethod=*/true);
4025     auto CC = MD->getType()->getAs<FunctionProtoType>()->getCallConv();
4026     return CC == DefaultCC;
4027   };
4028
4029   if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND)) {
4030     Manglings.emplace_back(getMangledStructor(M, DL, CD, Ctor_Base));
4031
4032     if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily())
4033       if (!CD->getParent()->isAbstract())
4034         Manglings.emplace_back(getMangledStructor(M, DL, CD, Ctor_Complete));
4035
4036     if (Ctx.getTargetInfo().getCXXABI().isMicrosoft())
4037       if (CD->hasAttr<DLLExportAttr>() && CD->isDefaultConstructor())
4038         if (!(hasDefaultCXXMethodCC(Ctx, CD) && CD->getNumParams() == 0))
4039           Manglings.emplace_back(getMangledStructor(M, DL, CD,
4040                                                     Ctor_DefaultClosure));
4041   } else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND)) {
4042     Manglings.emplace_back(getMangledStructor(M, DL, DD, Dtor_Base));
4043     if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily()) {
4044       Manglings.emplace_back(getMangledStructor(M, DL, DD, Dtor_Complete));
4045       if (DD->isVirtual())
4046         Manglings.emplace_back(getMangledStructor(M, DL, DD, Dtor_Deleting));
4047     }
4048   }
4049
4050   return cxstring::createSet(Manglings);
4051 }
4052
4053 CXString clang_getCursorDisplayName(CXCursor C) {
4054   if (!clang_isDeclaration(C.kind))
4055     return clang_getCursorSpelling(C);
4056
4057   const Decl *D = getCursorDecl(C);
4058   if (!D)
4059     return cxstring::createEmpty();
4060
4061   PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy();
4062   if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
4063     D = FunTmpl->getTemplatedDecl();
4064
4065   if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
4066     SmallString<64> Str;
4067     llvm::raw_svector_ostream OS(Str);
4068     OS << *Function;
4069     if (Function->getPrimaryTemplate())
4070       OS << "<>";
4071     OS << "(";
4072     for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) {
4073       if (I)
4074         OS << ", ";
4075       OS << Function->getParamDecl(I)->getType().getAsString(Policy);
4076     }
4077
4078     if (Function->isVariadic()) {
4079       if (Function->getNumParams())
4080         OS << ", ";
4081       OS << "...";
4082     }
4083     OS << ")";
4084     return cxstring::createDup(OS.str());
4085   }
4086
4087   if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) {
4088     SmallString<64> Str;
4089     llvm::raw_svector_ostream OS(Str);
4090     OS << *ClassTemplate;
4091     OS << "<";
4092     TemplateParameterList *Params = ClassTemplate->getTemplateParameters();
4093     for (unsigned I = 0, N = Params->size(); I != N; ++I) {
4094       if (I)
4095         OS << ", ";
4096
4097       NamedDecl *Param = Params->getParam(I);
4098       if (Param->getIdentifier()) {
4099         OS << Param->getIdentifier()->getName();
4100         continue;
4101       }
4102
4103       // There is no parameter name, which makes this tricky. Try to come up
4104       // with something useful that isn't too long.
4105       if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
4106         OS << (TTP->wasDeclaredWithTypename()? "typename" : "class");
4107       else if (NonTypeTemplateParmDecl *NTTP
4108                                     = dyn_cast<NonTypeTemplateParmDecl>(Param))
4109         OS << NTTP->getType().getAsString(Policy);
4110       else
4111         OS << "template<...> class";
4112     }
4113
4114     OS << ">";
4115     return cxstring::createDup(OS.str());
4116   }
4117
4118   if (const ClassTemplateSpecializationDecl *ClassSpec
4119                               = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
4120     // If the type was explicitly written, use that.
4121     if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten())
4122       return cxstring::createDup(TSInfo->getType().getAsString(Policy));
4123
4124     SmallString<128> Str;
4125     llvm::raw_svector_ostream OS(Str);
4126     OS << *ClassSpec;
4127     TemplateSpecializationType::PrintTemplateArgumentList(OS,
4128                                       ClassSpec->getTemplateArgs().data(),
4129                                       ClassSpec->getTemplateArgs().size(),
4130                                                                 Policy);
4131     return cxstring::createDup(OS.str());
4132   }
4133
4134   return clang_getCursorSpelling(C);
4135 }
4136
4137 CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
4138   switch (Kind) {
4139   case CXCursor_FunctionDecl:
4140       return cxstring::createRef("FunctionDecl");
4141   case CXCursor_TypedefDecl:
4142       return cxstring::createRef("TypedefDecl");
4143   case CXCursor_EnumDecl:
4144       return cxstring::createRef("EnumDecl");
4145   case CXCursor_EnumConstantDecl:
4146       return cxstring::createRef("EnumConstantDecl");
4147   case CXCursor_StructDecl:
4148       return cxstring::createRef("StructDecl");
4149   case CXCursor_UnionDecl:
4150       return cxstring::createRef("UnionDecl");
4151   case CXCursor_ClassDecl:
4152       return cxstring::createRef("ClassDecl");
4153   case CXCursor_FieldDecl:
4154       return cxstring::createRef("FieldDecl");
4155   case CXCursor_VarDecl:
4156       return cxstring::createRef("VarDecl");
4157   case CXCursor_ParmDecl:
4158       return cxstring::createRef("ParmDecl");
4159   case CXCursor_ObjCInterfaceDecl:
4160       return cxstring::createRef("ObjCInterfaceDecl");
4161   case CXCursor_ObjCCategoryDecl:
4162       return cxstring::createRef("ObjCCategoryDecl");
4163   case CXCursor_ObjCProtocolDecl:
4164       return cxstring::createRef("ObjCProtocolDecl");
4165   case CXCursor_ObjCPropertyDecl:
4166       return cxstring::createRef("ObjCPropertyDecl");
4167   case CXCursor_ObjCIvarDecl:
4168       return cxstring::createRef("ObjCIvarDecl");
4169   case CXCursor_ObjCInstanceMethodDecl:
4170       return cxstring::createRef("ObjCInstanceMethodDecl");
4171   case CXCursor_ObjCClassMethodDecl:
4172       return cxstring::createRef("ObjCClassMethodDecl");
4173   case CXCursor_ObjCImplementationDecl:
4174       return cxstring::createRef("ObjCImplementationDecl");
4175   case CXCursor_ObjCCategoryImplDecl:
4176       return cxstring::createRef("ObjCCategoryImplDecl");
4177   case CXCursor_CXXMethod:
4178       return cxstring::createRef("CXXMethod");
4179   case CXCursor_UnexposedDecl:
4180       return cxstring::createRef("UnexposedDecl");
4181   case CXCursor_ObjCSuperClassRef:
4182       return cxstring::createRef("ObjCSuperClassRef");
4183   case CXCursor_ObjCProtocolRef:
4184       return cxstring::createRef("ObjCProtocolRef");
4185   case CXCursor_ObjCClassRef:
4186       return cxstring::createRef("ObjCClassRef");
4187   case CXCursor_TypeRef:
4188       return cxstring::createRef("TypeRef");
4189   case CXCursor_TemplateRef:
4190       return cxstring::createRef("TemplateRef");
4191   case CXCursor_NamespaceRef:
4192     return cxstring::createRef("NamespaceRef");
4193   case CXCursor_MemberRef:
4194     return cxstring::createRef("MemberRef");
4195   case CXCursor_LabelRef:
4196     return cxstring::createRef("LabelRef");
4197   case CXCursor_OverloadedDeclRef:
4198     return cxstring::createRef("OverloadedDeclRef");
4199   case CXCursor_VariableRef:
4200     return cxstring::createRef("VariableRef");
4201   case CXCursor_IntegerLiteral:
4202       return cxstring::createRef("IntegerLiteral");
4203   case CXCursor_FloatingLiteral:
4204       return cxstring::createRef("FloatingLiteral");
4205   case CXCursor_ImaginaryLiteral:
4206       return cxstring::createRef("ImaginaryLiteral");
4207   case CXCursor_StringLiteral:
4208       return cxstring::createRef("StringLiteral");
4209   case CXCursor_CharacterLiteral:
4210       return cxstring::createRef("CharacterLiteral");
4211   case CXCursor_ParenExpr:
4212       return cxstring::createRef("ParenExpr");
4213   case CXCursor_UnaryOperator:
4214       return cxstring::createRef("UnaryOperator");
4215   case CXCursor_ArraySubscriptExpr:
4216       return cxstring::createRef("ArraySubscriptExpr");
4217   case CXCursor_OMPArraySectionExpr:
4218       return cxstring::createRef("OMPArraySectionExpr");
4219   case CXCursor_BinaryOperator:
4220       return cxstring::createRef("BinaryOperator");
4221   case CXCursor_CompoundAssignOperator:
4222       return cxstring::createRef("CompoundAssignOperator");
4223   case CXCursor_ConditionalOperator:
4224       return cxstring::createRef("ConditionalOperator");
4225   case CXCursor_CStyleCastExpr:
4226       return cxstring::createRef("CStyleCastExpr");
4227   case CXCursor_CompoundLiteralExpr:
4228       return cxstring::createRef("CompoundLiteralExpr");
4229   case CXCursor_InitListExpr:
4230       return cxstring::createRef("InitListExpr");
4231   case CXCursor_AddrLabelExpr:
4232       return cxstring::createRef("AddrLabelExpr");
4233   case CXCursor_StmtExpr:
4234       return cxstring::createRef("StmtExpr");
4235   case CXCursor_GenericSelectionExpr:
4236       return cxstring::createRef("GenericSelectionExpr");
4237   case CXCursor_GNUNullExpr:
4238       return cxstring::createRef("GNUNullExpr");
4239   case CXCursor_CXXStaticCastExpr:
4240       return cxstring::createRef("CXXStaticCastExpr");
4241   case CXCursor_CXXDynamicCastExpr:
4242       return cxstring::createRef("CXXDynamicCastExpr");
4243   case CXCursor_CXXReinterpretCastExpr:
4244       return cxstring::createRef("CXXReinterpretCastExpr");
4245   case CXCursor_CXXConstCastExpr:
4246       return cxstring::createRef("CXXConstCastExpr");
4247   case CXCursor_CXXFunctionalCastExpr:
4248       return cxstring::createRef("CXXFunctionalCastExpr");
4249   case CXCursor_CXXTypeidExpr:
4250       return cxstring::createRef("CXXTypeidExpr");
4251   case CXCursor_CXXBoolLiteralExpr:
4252       return cxstring::createRef("CXXBoolLiteralExpr");
4253   case CXCursor_CXXNullPtrLiteralExpr:
4254       return cxstring::createRef("CXXNullPtrLiteralExpr");
4255   case CXCursor_CXXThisExpr:
4256       return cxstring::createRef("CXXThisExpr");
4257   case CXCursor_CXXThrowExpr:
4258       return cxstring::createRef("CXXThrowExpr");
4259   case CXCursor_CXXNewExpr:
4260       return cxstring::createRef("CXXNewExpr");
4261   case CXCursor_CXXDeleteExpr:
4262       return cxstring::createRef("CXXDeleteExpr");
4263   case CXCursor_UnaryExpr:
4264       return cxstring::createRef("UnaryExpr");
4265   case CXCursor_ObjCStringLiteral:
4266       return cxstring::createRef("ObjCStringLiteral");
4267   case CXCursor_ObjCBoolLiteralExpr:
4268       return cxstring::createRef("ObjCBoolLiteralExpr");
4269   case CXCursor_ObjCSelfExpr:
4270       return cxstring::createRef("ObjCSelfExpr");
4271   case CXCursor_ObjCEncodeExpr:
4272       return cxstring::createRef("ObjCEncodeExpr");
4273   case CXCursor_ObjCSelectorExpr:
4274       return cxstring::createRef("ObjCSelectorExpr");
4275   case CXCursor_ObjCProtocolExpr:
4276       return cxstring::createRef("ObjCProtocolExpr");
4277   case CXCursor_ObjCBridgedCastExpr:
4278       return cxstring::createRef("ObjCBridgedCastExpr");
4279   case CXCursor_BlockExpr:
4280       return cxstring::createRef("BlockExpr");
4281   case CXCursor_PackExpansionExpr:
4282       return cxstring::createRef("PackExpansionExpr");
4283   case CXCursor_SizeOfPackExpr:
4284       return cxstring::createRef("SizeOfPackExpr");
4285   case CXCursor_LambdaExpr:
4286     return cxstring::createRef("LambdaExpr");
4287   case CXCursor_UnexposedExpr:
4288       return cxstring::createRef("UnexposedExpr");
4289   case CXCursor_DeclRefExpr:
4290       return cxstring::createRef("DeclRefExpr");
4291   case CXCursor_MemberRefExpr:
4292       return cxstring::createRef("MemberRefExpr");
4293   case CXCursor_CallExpr:
4294       return cxstring::createRef("CallExpr");
4295   case CXCursor_ObjCMessageExpr:
4296       return cxstring::createRef("ObjCMessageExpr");
4297   case CXCursor_UnexposedStmt:
4298       return cxstring::createRef("UnexposedStmt");
4299   case CXCursor_DeclStmt:
4300       return cxstring::createRef("DeclStmt");
4301   case CXCursor_LabelStmt:
4302       return cxstring::createRef("LabelStmt");
4303   case CXCursor_CompoundStmt:
4304       return cxstring::createRef("CompoundStmt");
4305   case CXCursor_CaseStmt:
4306       return cxstring::createRef("CaseStmt");
4307   case CXCursor_DefaultStmt:
4308       return cxstring::createRef("DefaultStmt");
4309   case CXCursor_IfStmt:
4310       return cxstring::createRef("IfStmt");
4311   case CXCursor_SwitchStmt:
4312       return cxstring::createRef("SwitchStmt");
4313   case CXCursor_WhileStmt:
4314       return cxstring::createRef("WhileStmt");
4315   case CXCursor_DoStmt:
4316       return cxstring::createRef("DoStmt");
4317   case CXCursor_ForStmt:
4318       return cxstring::createRef("ForStmt");
4319   case CXCursor_GotoStmt:
4320       return cxstring::createRef("GotoStmt");
4321   case CXCursor_IndirectGotoStmt:
4322       return cxstring::createRef("IndirectGotoStmt");
4323   case CXCursor_ContinueStmt:
4324       return cxstring::createRef("ContinueStmt");
4325   case CXCursor_BreakStmt:
4326       return cxstring::createRef("BreakStmt");
4327   case CXCursor_ReturnStmt:
4328       return cxstring::createRef("ReturnStmt");
4329   case CXCursor_GCCAsmStmt:
4330       return cxstring::createRef("GCCAsmStmt");
4331   case CXCursor_MSAsmStmt:
4332       return cxstring::createRef("MSAsmStmt");
4333   case CXCursor_ObjCAtTryStmt:
4334       return cxstring::createRef("ObjCAtTryStmt");
4335   case CXCursor_ObjCAtCatchStmt:
4336       return cxstring::createRef("ObjCAtCatchStmt");
4337   case CXCursor_ObjCAtFinallyStmt:
4338       return cxstring::createRef("ObjCAtFinallyStmt");
4339   case CXCursor_ObjCAtThrowStmt:
4340       return cxstring::createRef("ObjCAtThrowStmt");
4341   case CXCursor_ObjCAtSynchronizedStmt:
4342       return cxstring::createRef("ObjCAtSynchronizedStmt");
4343   case CXCursor_ObjCAutoreleasePoolStmt:
4344       return cxstring::createRef("ObjCAutoreleasePoolStmt");
4345   case CXCursor_ObjCForCollectionStmt:
4346       return cxstring::createRef("ObjCForCollectionStmt");
4347   case CXCursor_CXXCatchStmt:
4348       return cxstring::createRef("CXXCatchStmt");
4349   case CXCursor_CXXTryStmt:
4350       return cxstring::createRef("CXXTryStmt");
4351   case CXCursor_CXXForRangeStmt:
4352       return cxstring::createRef("CXXForRangeStmt");
4353   case CXCursor_SEHTryStmt:
4354       return cxstring::createRef("SEHTryStmt");
4355   case CXCursor_SEHExceptStmt:
4356       return cxstring::createRef("SEHExceptStmt");
4357   case CXCursor_SEHFinallyStmt:
4358       return cxstring::createRef("SEHFinallyStmt");
4359   case CXCursor_SEHLeaveStmt:
4360       return cxstring::createRef("SEHLeaveStmt");
4361   case CXCursor_NullStmt:
4362       return cxstring::createRef("NullStmt");
4363   case CXCursor_InvalidFile:
4364       return cxstring::createRef("InvalidFile");
4365   case CXCursor_InvalidCode:
4366     return cxstring::createRef("InvalidCode");
4367   case CXCursor_NoDeclFound:
4368       return cxstring::createRef("NoDeclFound");
4369   case CXCursor_NotImplemented:
4370       return cxstring::createRef("NotImplemented");
4371   case CXCursor_TranslationUnit:
4372       return cxstring::createRef("TranslationUnit");
4373   case CXCursor_UnexposedAttr:
4374       return cxstring::createRef("UnexposedAttr");
4375   case CXCursor_IBActionAttr:
4376       return cxstring::createRef("attribute(ibaction)");
4377   case CXCursor_IBOutletAttr:
4378      return cxstring::createRef("attribute(iboutlet)");
4379   case CXCursor_IBOutletCollectionAttr:
4380       return cxstring::createRef("attribute(iboutletcollection)");
4381   case CXCursor_CXXFinalAttr:
4382       return cxstring::createRef("attribute(final)");
4383   case CXCursor_CXXOverrideAttr:
4384       return cxstring::createRef("attribute(override)");
4385   case CXCursor_AnnotateAttr:
4386     return cxstring::createRef("attribute(annotate)");
4387   case CXCursor_AsmLabelAttr:
4388     return cxstring::createRef("asm label");
4389   case CXCursor_PackedAttr:
4390     return cxstring::createRef("attribute(packed)");
4391   case CXCursor_PureAttr:
4392     return cxstring::createRef("attribute(pure)");
4393   case CXCursor_ConstAttr:
4394     return cxstring::createRef("attribute(const)");
4395   case CXCursor_NoDuplicateAttr:
4396     return cxstring::createRef("attribute(noduplicate)");
4397   case CXCursor_CUDAConstantAttr:
4398     return cxstring::createRef("attribute(constant)");
4399   case CXCursor_CUDADeviceAttr:
4400     return cxstring::createRef("attribute(device)");
4401   case CXCursor_CUDAGlobalAttr:
4402     return cxstring::createRef("attribute(global)");
4403   case CXCursor_CUDAHostAttr:
4404     return cxstring::createRef("attribute(host)");
4405   case CXCursor_CUDASharedAttr:
4406     return cxstring::createRef("attribute(shared)");
4407   case CXCursor_VisibilityAttr:
4408     return cxstring::createRef("attribute(visibility)");
4409   case CXCursor_DLLExport:
4410     return cxstring::createRef("attribute(dllexport)");
4411   case CXCursor_DLLImport:
4412     return cxstring::createRef("attribute(dllimport)");
4413   case CXCursor_PreprocessingDirective:
4414     return cxstring::createRef("preprocessing directive");
4415   case CXCursor_MacroDefinition:
4416     return cxstring::createRef("macro definition");
4417   case CXCursor_MacroExpansion:
4418     return cxstring::createRef("macro expansion");
4419   case CXCursor_InclusionDirective:
4420     return cxstring::createRef("inclusion directive");
4421   case CXCursor_Namespace:
4422     return cxstring::createRef("Namespace");
4423   case CXCursor_LinkageSpec:
4424     return cxstring::createRef("LinkageSpec");
4425   case CXCursor_CXXBaseSpecifier:
4426     return cxstring::createRef("C++ base class specifier");
4427   case CXCursor_Constructor:
4428     return cxstring::createRef("CXXConstructor");
4429   case CXCursor_Destructor:
4430     return cxstring::createRef("CXXDestructor");
4431   case CXCursor_ConversionFunction:
4432     return cxstring::createRef("CXXConversion");
4433   case CXCursor_TemplateTypeParameter:
4434     return cxstring::createRef("TemplateTypeParameter");
4435   case CXCursor_NonTypeTemplateParameter:
4436     return cxstring::createRef("NonTypeTemplateParameter");
4437   case CXCursor_TemplateTemplateParameter:
4438     return cxstring::createRef("TemplateTemplateParameter");
4439   case CXCursor_FunctionTemplate:
4440     return cxstring::createRef("FunctionTemplate");
4441   case CXCursor_ClassTemplate:
4442     return cxstring::createRef("ClassTemplate");
4443   case CXCursor_ClassTemplatePartialSpecialization:
4444