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