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