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