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