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