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