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