granicus.if.org Git - clang/blob - tools/libclang/CIndex.cpp

   1 //===- CIndex.cpp - Clang-C Source Indexing Library -----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the main API hooks in the Clang-C Source Indexing
  11 // library.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "CIndexer.h"
  16 #include "CIndexDiagnostic.h"
  17 #include "CLog.h"
  18 #include "CXCursor.h"
  19 #include "CXSourceLocation.h"
  20 #include "CXString.h"
  21 #include "CXTranslationUnit.h"
  22 #include "CXType.h"
  23 #include "CursorVisitor.h"
  24 #include "clang/AST/Attr.h"
  25 #include "clang/AST/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_ObjCAvailabilityCheckExpr:
4615       return cxstring::createRef("ObjCAvailabilityCheckExpr");
4616   case CXCursor_ObjCSelfExpr:
4617       return cxstring::createRef("ObjCSelfExpr");
4618   case CXCursor_ObjCEncodeExpr:
4619       return cxstring::createRef("ObjCEncodeExpr");
4620   case CXCursor_ObjCSelectorExpr:
4621       return cxstring::createRef("ObjCSelectorExpr");
4622   case CXCursor_ObjCProtocolExpr:
4623       return cxstring::createRef("ObjCProtocolExpr");
4624   case CXCursor_ObjCBridgedCastExpr:
4625       return cxstring::createRef("ObjCBridgedCastExpr");
4626   case CXCursor_BlockExpr:
4627       return cxstring::createRef("BlockExpr");
4628   case CXCursor_PackExpansionExpr:
4629       return cxstring::createRef("PackExpansionExpr");
4630   case CXCursor_SizeOfPackExpr:
4631       return cxstring::createRef("SizeOfPackExpr");
4632   case CXCursor_LambdaExpr:
4633     return cxstring::createRef("LambdaExpr");
4634   case CXCursor_UnexposedExpr:
4635       return cxstring::createRef("UnexposedExpr");
4636   case CXCursor_DeclRefExpr:
4637       return cxstring::createRef("DeclRefExpr");
4638   case CXCursor_MemberRefExpr:
4639       return cxstring::createRef("MemberRefExpr");
4640   case CXCursor_CallExpr:
4641       return cxstring::createRef("CallExpr");
4642   case CXCursor_ObjCMessageExpr:
4643       return cxstring::createRef("ObjCMessageExpr");
4644   case CXCursor_UnexposedStmt:
4645       return cxstring::createRef("UnexposedStmt");
4646   case CXCursor_DeclStmt:
4647       return cxstring::createRef("DeclStmt");
4648   case CXCursor_LabelStmt:
4649       return cxstring::createRef("LabelStmt");
4650   case CXCursor_CompoundStmt:
4651       return cxstring::createRef("CompoundStmt");
4652   case CXCursor_CaseStmt:
4653       return cxstring::createRef("CaseStmt");
4654   case CXCursor_DefaultStmt:
4655       return cxstring::createRef("DefaultStmt");
4656   case CXCursor_IfStmt:
4657       return cxstring::createRef("IfStmt");
4658   case CXCursor_SwitchStmt:
4659       return cxstring::createRef("SwitchStmt");
4660   case CXCursor_WhileStmt:
4661       return cxstring::createRef("WhileStmt");
4662   case CXCursor_DoStmt:
4663       return cxstring::createRef("DoStmt");
4664   case CXCursor_ForStmt:
4665       return cxstring::createRef("ForStmt");
4666   case CXCursor_GotoStmt:
4667       return cxstring::createRef("GotoStmt");
4668   case CXCursor_IndirectGotoStmt:
4669       return cxstring::createRef("IndirectGotoStmt");
4670   case CXCursor_ContinueStmt:
4671       return cxstring::createRef("ContinueStmt");
4672   case CXCursor_BreakStmt:
4673       return cxstring::createRef("BreakStmt");
4674   case CXCursor_ReturnStmt:
4675       return cxstring::createRef("ReturnStmt");
4676   case CXCursor_GCCAsmStmt:
4677       return cxstring::createRef("GCCAsmStmt");
4678   case CXCursor_MSAsmStmt:
4679       return cxstring::createRef("MSAsmStmt");
4680   case CXCursor_ObjCAtTryStmt:
4681       return cxstring::createRef("ObjCAtTryStmt");
4682   case CXCursor_ObjCAtCatchStmt:
4683       return cxstring::createRef("ObjCAtCatchStmt");
4684   case CXCursor_ObjCAtFinallyStmt:
4685       return cxstring::createRef("ObjCAtFinallyStmt");
4686   case CXCursor_ObjCAtThrowStmt:
4687       return cxstring::createRef("ObjCAtThrowStmt");
4688   case CXCursor_ObjCAtSynchronizedStmt:
4689       return cxstring::createRef("ObjCAtSynchronizedStmt");
4690   case CXCursor_ObjCAutoreleasePoolStmt:
4691       return cxstring::createRef("ObjCAutoreleasePoolStmt");
4692   case CXCursor_ObjCForCollectionStmt:
4693       return cxstring::createRef("ObjCForCollectionStmt");
4694   case CXCursor_CXXCatchStmt:
4695       return cxstring::createRef("CXXCatchStmt");
4696   case CXCursor_CXXTryStmt:
4697       return cxstring::createRef("CXXTryStmt");
4698   case CXCursor_CXXForRangeStmt:
4699       return cxstring::createRef("CXXForRangeStmt");
4700   case CXCursor_SEHTryStmt:
4701       return cxstring::createRef("SEHTryStmt");
4702   case CXCursor_SEHExceptStmt:
4703       return cxstring::createRef("SEHExceptStmt");
4704   case CXCursor_SEHFinallyStmt:
4705       return cxstring::createRef("SEHFinallyStmt");
4706   case CXCursor_SEHLeaveStmt:
4707       return cxstring::createRef("SEHLeaveStmt");
4708   case CXCursor_NullStmt:
4709       return cxstring::createRef("NullStmt");
4710   case CXCursor_InvalidFile:
4711       return cxstring::createRef("InvalidFile");
4712   case CXCursor_InvalidCode:
4713     return cxstring::createRef("InvalidCode");
4714   case CXCursor_NoDeclFound:
4715       return cxstring::createRef("NoDeclFound");
4716   case CXCursor_NotImplemented:
4717       return cxstring::createRef("NotImplemented");
4718   case CXCursor_TranslationUnit:
4719       return cxstring::createRef("TranslationUnit");
4720   case CXCursor_UnexposedAttr:
4721       return cxstring::createRef("UnexposedAttr");
4722   case CXCursor_IBActionAttr:
4723       return cxstring::createRef("attribute(ibaction)");
4724   case CXCursor_IBOutletAttr:
4725      return cxstring::createRef("attribute(iboutlet)");
4726   case CXCursor_IBOutletCollectionAttr:
4727       return cxstring::createRef("attribute(iboutletcollection)");
4728   case CXCursor_CXXFinalAttr:
4729       return cxstring::createRef("attribute(final)");
4730   case CXCursor_CXXOverrideAttr:
4731       return cxstring::createRef("attribute(override)");
4732   case CXCursor_AnnotateAttr:
4733     return cxstring::createRef("attribute(annotate)");
4734   case CXCursor_AsmLabelAttr:
4735     return cxstring::createRef("asm label");
4736   case CXCursor_PackedAttr:
4737     return cxstring::createRef("attribute(packed)");
4738   case CXCursor_PureAttr:
4739     return cxstring::createRef("attribute(pure)");
4740   case CXCursor_ConstAttr:
4741     return cxstring::createRef("attribute(const)");
4742   case CXCursor_NoDuplicateAttr:
4743     return cxstring::createRef("attribute(noduplicate)");
4744   case CXCursor_CUDAConstantAttr:
4745     return cxstring::createRef("attribute(constant)");
4746   case CXCursor_CUDADeviceAttr:
4747     return cxstring::createRef("attribute(device)");
4748   case CXCursor_CUDAGlobalAttr:
4749     return cxstring::createRef("attribute(global)");
4750   case CXCursor_CUDAHostAttr:
4751     return cxstring::createRef("attribute(host)");
4752   case CXCursor_CUDASharedAttr:
4753     return cxstring::createRef("attribute(shared)");
4754   case CXCursor_VisibilityAttr:
4755     return cxstring::createRef("attribute(visibility)");
4756   case CXCursor_DLLExport:
4757     return cxstring::createRef("attribute(dllexport)");
4758   case CXCursor_DLLImport:
4759     return cxstring::createRef("attribute(dllimport)");
4760   case CXCursor_PreprocessingDirective:
4761     return cxstring::createRef("preprocessing directive");
4762   case CXCursor_MacroDefinition:
4763     return cxstring::createRef("macro definition");
4764   case CXCursor_MacroExpansion:
4765     return cxstring::createRef("macro expansion");
4766   case CXCursor_InclusionDirective:
4767     return cxstring::createRef("inclusion directive");
4768   case CXCursor_Namespace:
4769     return cxstring::createRef("Namespace");
4770   case CXCursor_LinkageSpec:
4771     return cxstring::createRef("LinkageSpec");
4772   case CXCursor_CXXBaseSpecifier:
4773     return cxstring::createRef("C++ base class specifier");
4774   case CXCursor_Constructor:
4775     return cxstring::createRef("CXXConstructor");
4776   case CXCursor_Destructor:
4777     return cxstring::createRef("CXXDestructor");
4778   case CXCursor_ConversionFunction:
4779     return cxstring::createRef("CXXConversion");
4780   case CXCursor_TemplateTypeParameter:
4781     return cxstring::createRef("TemplateTypeParameter");
4782   case CXCursor_NonTypeTemplateParameter:
4783     return cxstring::createRef("NonTypeTemplateParameter");
4784   case CXCursor_TemplateTemplateParameter:
4785     return cxstring::createRef("TemplateTemplateParameter");
4786   case CXCursor_FunctionTemplate:
4787     return cxstring::createRef("FunctionTemplate");
4788   case CXCursor_ClassTemplate:
4789     return cxstring::createRef("ClassTemplate");
4790   case CXCursor_ClassTemplatePartialSpecialization:
4791     return cxstring::createRef("ClassTemplatePartialSpecialization");
4792   case CXCursor_NamespaceAlias:
4793     return cxstring::createRef("NamespaceAlias");
4794   case CXCursor_UsingDirective:
4795     return cxstring::createRef("UsingDirective");
4796   case CXCursor_UsingDeclaration:
4797     return cxstring::createRef("UsingDeclaration");
4798   case CXCursor_TypeAliasDecl:
4799     return cxstring::createRef("TypeAliasDecl");
4800   case CXCursor_ObjCSynthesizeDecl:
4801     return cxstring::createRef("ObjCSynthesizeDecl");
4802   case CXCursor_ObjCDynamicDecl:
4803     return cxstring::createRef("ObjCDynamicDecl");
4804   case CXCursor_CXXAccessSpecifier:
4805     return cxstring::createRef("CXXAccessSpecifier");
4806   case CXCursor_ModuleImportDecl:
4807     return cxstring::createRef("ModuleImport");
4808   case CXCursor_OMPParallelDirective:
4809     return cxstring::createRef("OMPParallelDirective");
4810   case CXCursor_OMPSimdDirective:
4811     return cxstring::createRef("OMPSimdDirective");
4812   case CXCursor_OMPForDirective:
4813     return cxstring::createRef("OMPForDirective");
4814   case CXCursor_OMPForSimdDirective:
4815     return cxstring::createRef("OMPForSimdDirective");
4816   case CXCursor_OMPSectionsDirective:
4817     return cxstring::createRef("OMPSectionsDirective");
4818   case CXCursor_OMPSectionDirective:
4819     return cxstring::createRef("OMPSectionDirective");
4820   case CXCursor_OMPSingleDirective:
4821     return cxstring::createRef("OMPSingleDirective");
4822   case CXCursor_OMPMasterDirective:
4823     return cxstring::createRef("OMPMasterDirective");
4824   case CXCursor_OMPCriticalDirective:
4825     return cxstring::createRef("OMPCriticalDirective");
4826   case CXCursor_OMPParallelForDirective:
4827     return cxstring::createRef("OMPParallelForDirective");
4828   case CXCursor_OMPParallelForSimdDirective:
4829     return cxstring::createRef("OMPParallelForSimdDirective");
4830   case CXCursor_OMPParallelSectionsDirective:
4831     return cxstring::createRef("OMPParallelSectionsDirective");
4832   case CXCursor_OMPTaskDirective:
4833     return cxstring::createRef("OMPTaskDirective");
4834   case CXCursor_OMPTaskyieldDirective:
4835     return cxstring::createRef("OMPTaskyieldDirective");
4836   case CXCursor_OMPBarrierDirective:
4837     return cxstring::createRef("OMPBarrierDirective");
4838   case CXCursor_OMPTaskwaitDirective:
4839     return cxstring::createRef("OMPTaskwaitDirective");
4840   case CXCursor_OMPTaskgroupDirective:
4841     return cxstring::createRef("OMPTaskgroupDirective");
4842   case CXCursor_OMPFlushDirective:
4843     return cxstring::createRef("OMPFlushDirective");
4844   case CXCursor_OMPOrderedDirective:
4845     return cxstring::createRef("OMPOrderedDirective");
4846   case CXCursor_OMPAtomicDirective:
4847     return cxstring::createRef("OMPAtomicDirective");
4848   case CXCursor_OMPTargetDirective:
4849     return cxstring::createRef("OMPTargetDirective");
4850   case CXCursor_OMPTargetDataDirective:
4851     return cxstring::createRef("OMPTargetDataDirective");
4852   case CXCursor_OMPTargetEnterDataDirective:
4853     return cxstring::createRef("OMPTargetEnterDataDirective");
4854   case CXCursor_OMPTargetExitDataDirective:
4855     return cxstring::createRef("OMPTargetExitDataDirective");
4856   case CXCursor_OMPTargetParallelDirective:
4857     return cxstring::createRef("OMPTargetParallelDirective");
4858   case CXCursor_OMPTargetParallelForDirective:
4859     return cxstring::createRef("OMPTargetParallelForDirective");
4860   case CXCursor_OMPTargetUpdateDirective:
4861     return cxstring::createRef("OMPTargetUpdateDirective");
4862   case CXCursor_OMPTeamsDirective:
4863     return cxstring::createRef("OMPTeamsDirective");
4864   case CXCursor_OMPCancellationPointDirective:
4865     return cxstring::createRef("OMPCancellationPointDirective");
4866   case CXCursor_OMPCancelDirective:
4867     return cxstring::createRef("OMPCancelDirective");
4868   case CXCursor_OMPTaskLoopDirective:
4869     return cxstring::createRef("OMPTaskLoopDirective");
4870   case CXCursor_OMPTaskLoopSimdDirective:
4871     return cxstring::createRef("OMPTaskLoopSimdDirective");
4872   case CXCursor_OMPDistributeDirective:
4873     return cxstring::createRef("OMPDistributeDirective");
4874   case CXCursor_OMPDistributeParallelForDirective:
4875     return cxstring::createRef("OMPDistributeParallelForDirective");
4876   case CXCursor_OMPDistributeParallelForSimdDirective:
4877     return cxstring::createRef("OMPDistributeParallelForSimdDirective");
4878   case CXCursor_OMPDistributeSimdDirective:
4879     return cxstring::createRef("OMPDistributeSimdDirective");
4880   case CXCursor_OMPTargetParallelForSimdDirective:
4881     return cxstring::createRef("OMPTargetParallelForSimdDirective");
4882   case CXCursor_OverloadCandidate:
4883       return cxstring::createRef("OverloadCandidate");
4884   case CXCursor_TypeAliasTemplateDecl:
4885       return cxstring::createRef("TypeAliasTemplateDecl");
4886   case CXCursor_StaticAssert:
4887       return cxstring::createRef("StaticAssert");
4888   }
4889
4890   llvm_unreachable("Unhandled CXCursorKind");
4891 }
4892
4893 struct GetCursorData {
4894   SourceLocation TokenBeginLoc;
4895   bool PointsAtMacroArgExpansion;
4896   bool VisitedObjCPropertyImplDecl;
4897   SourceLocation VisitedDeclaratorDeclStartLoc;
4898   CXCursor &BestCursor;
4899
4900   GetCursorData(SourceManager &SM,
4901                 SourceLocation tokenBegin, CXCursor &outputCursor)
4902     : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) {
4903     PointsAtMacroArgExpansion = SM.isMacroArgExpansion(tokenBegin);
4904     VisitedObjCPropertyImplDecl = false;
4905   }
4906 };
4907
4908 static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor,
4909                                                 CXCursor parent,
4910                                                 CXClientData client_data) {
4911   GetCursorData *Data = static_cast<GetCursorData *>(client_data);
4912   CXCursor *BestCursor = &Data->BestCursor;
4913
4914   // If we point inside a macro argument we should provide info of what the
4915   // token is so use the actual cursor, don't replace it with a macro expansion
4916   // cursor.
4917   if (cursor.kind == CXCursor_MacroExpansion && Data->PointsAtMacroArgExpansion)
4918     return CXChildVisit_Recurse;
4919
4920   if (clang_isDeclaration(cursor.kind)) {
4921     // Avoid having the implicit methods override the property decls.
4922     if (const ObjCMethodDecl *MD
4923           = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) {
4924       if (MD->isImplicit())
4925         return CXChildVisit_Break;
4926
4927     } else if (const ObjCInterfaceDecl *ID
4928                  = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(cursor))) {
4929       // Check that when we have multiple @class references in the same line,
4930       // that later ones do not override the previous ones.
4931       // If we have:
4932       // @class Foo, Bar;
4933       // source ranges for both start at '@', so 'Bar' will end up overriding
4934       // 'Foo' even though the cursor location was at 'Foo'.
4935       if (BestCursor->kind == CXCursor_ObjCInterfaceDecl ||
4936           BestCursor->kind == CXCursor_ObjCClassRef)
4937         if (const ObjCInterfaceDecl *PrevID
4938              = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(*BestCursor))){
4939          if (PrevID != ID &&
4940              !PrevID->isThisDeclarationADefinition() &&
4941              !ID->isThisDeclarationADefinition())
4942            return CXChildVisit_Break;
4943         }
4944
4945     } else if (const DeclaratorDecl *DD
4946                     = dyn_cast_or_null<DeclaratorDecl>(getCursorDecl(cursor))) {
4947       SourceLocation StartLoc = DD->getSourceRange().getBegin();
4948       // Check that when we have multiple declarators in the same line,
4949       // that later ones do not override the previous ones.
4950       // If we have:
4951       // int Foo, Bar;
4952       // source ranges for both start at 'int', so 'Bar' will end up overriding
4953       // 'Foo' even though the cursor location was at 'Foo'.
4954       if (Data->VisitedDeclaratorDeclStartLoc == StartLoc)
4955         return CXChildVisit_Break;
4956       Data->VisitedDeclaratorDeclStartLoc = StartLoc;
4957
4958     } else if (const ObjCPropertyImplDecl *PropImp
4959               = dyn_cast_or_null<ObjCPropertyImplDecl>(getCursorDecl(cursor))) {
4960       (void)PropImp;
4961       // Check that when we have multiple @synthesize in the same line,
4962       // that later ones do not override the previous ones.
4963       // If we have:
4964       // @synthesize Foo, Bar;
4965       // source ranges for both start at '@', so 'Bar' will end up overriding
4966       // 'Foo' even though the cursor location was at 'Foo'.
4967       if (Data->VisitedObjCPropertyImplDecl)
4968         return CXChildVisit_Break;
4969       Data->VisitedObjCPropertyImplDecl = true;
4970     }
4971   }
4972
4973   if (clang_isExpression(cursor.kind) &&
4974       clang_isDeclaration(BestCursor->kind)) {
4975     if (const Decl *D = getCursorDecl(*BestCursor)) {
4976       // Avoid having the cursor of an expression replace the declaration cursor
4977       // when the expression source range overlaps the declaration range.
4978       // This can happen for C++ constructor expressions whose range generally
4979       // include the variable declaration, e.g.:
4980       //  MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl cursor.
4981       if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() &&
4982           D->getLocation() == Data->TokenBeginLoc)
4983         return CXChildVisit_Break;
4984     }
4985   }
4986
4987   // If our current best cursor is the construction of a temporary object,
4988   // don't replace that cursor with a type reference, because we want
4989   // clang_getCursor() to point at the constructor.
4990   if (clang_isExpression(BestCursor->kind) &&
4991       isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) &&
4992       cursor.kind == CXCursor_TypeRef) {
4993     // Keep the cursor pointing at CXXTemporaryObjectExpr but also mark it
4994     // as having the actual point on the type reference.
4995     *BestCursor = getTypeRefedCallExprCursor(*BestCursor);
4996     return CXChildVisit_Recurse;
4997   }
4998
4999   // If we already have an Objective-C superclass reference, don't
5000   // update it further.
5001   if (BestCursor->kind == CXCursor_ObjCSuperClassRef)
5002     return CXChildVisit_Break;
5003
5004   *BestCursor = cursor;
5005   return CXChildVisit_Recurse;
5006 }
5007
5008 CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) {
5009   if (isNotUsableTU(TU)) {
5010     LOG_BAD_TU(TU);
5011     return clang_getNullCursor();
5012   }
5013
5014   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
5015   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
5016
5017   SourceLocation SLoc = cxloc::translateSourceLocation(Loc);
5018   CXCursor Result = cxcursor::getCursor(TU, SLoc);
5019
5020   LOG_FUNC_SECTION {
5021     CXFile SearchFile;
5022     unsigned SearchLine, SearchColumn;
5023     CXFile ResultFile;
5024     unsigned ResultLine, ResultColumn;
5025     CXString SearchFileName, ResultFileName, KindSpelling, USR;
5026     const char *IsDef = clang_isCursorDefinition(Result)? " (Definition)" : "";
5027     CXSourceLocation ResultLoc = clang_getCursorLocation(Result);
5028
5029     clang_getFileLocation(Loc, &SearchFile, &SearchLine, &SearchColumn,
5030                           nullptr);
5031     clang_getFileLocation(ResultLoc, &ResultFile, &ResultLine,
5032                           &ResultColumn, nullptr);
5033     SearchFileName = clang_getFileName(SearchFile);
5034     ResultFileName = clang_getFileName(ResultFile);
5035     KindSpelling = clang_getCursorKindSpelling(Result.kind);
5036     USR = clang_getCursorUSR(Result);
5037     *Log << llvm::format("(%s:%d:%d) = %s",
5038                    clang_getCString(SearchFileName), SearchLine, SearchColumn,
5039                    clang_getCString(KindSpelling))
5040         << llvm::format("(%s:%d:%d):%s%s",
5041                      clang_getCString(ResultFileName), ResultLine, ResultColumn,
5042                      clang_getCString(USR), IsDef);
5043     clang_disposeString(SearchFileName);
5044     clang_disposeString(ResultFileName);
5045     clang_disposeString(KindSpelling);
5046     clang_disposeString(USR);
5047
5048     CXCursor Definition = clang_getCursorDefinition(Result);
5049     if (!clang_equalCursors(Definition, clang_getNullCursor())) {
5050       CXSourceLocation DefinitionLoc = clang_getCursorLocation(Definition);
5051       CXString DefinitionKindSpelling
5052                                 = clang_getCursorKindSpelling(Definition.kind);
5053       CXFile DefinitionFile;
5054       unsigned DefinitionLine, DefinitionColumn;
5055       clang_getFileLocation(DefinitionLoc, &DefinitionFile,
5056                             &DefinitionLine, &DefinitionColumn, nullptr);
5057       CXString DefinitionFileName = clang_getFileName(DefinitionFile);
5058       *Log << llvm::format("  -> %s(%s:%d:%d)",
5059                      clang_getCString(DefinitionKindSpelling),
5060                      clang_getCString(DefinitionFileName),
5061                      DefinitionLine, DefinitionColumn);
5062       clang_disposeString(DefinitionFileName);
5063       clang_disposeString(DefinitionKindSpelling);
5064     }
5065   }
5066
5067   return Result;
5068 }
5069
5070 CXCursor clang_getNullCursor(void) {
5071   return MakeCXCursorInvalid(CXCursor_InvalidFile);
5072 }
5073
5074 unsigned clang_equalCursors(CXCursor X, CXCursor Y) {
5075   // Clear out the "FirstInDeclGroup" part in a declaration cursor, since we
5076   // can't set consistently. For example, when visiting a DeclStmt we will set
5077   // it but we don't set it on the result of clang_getCursorDefinition for
5078   // a reference of the same declaration.
5079   // FIXME: Setting "FirstInDeclGroup" in CXCursors is a hack that only works
5080   // when visiting a DeclStmt currently, the AST should be enhanced to be able
5081   // to provide that kind of info.
5082   if (clang_isDeclaration(X.kind))
5083     X.data[1] = nullptr;
5084   if (clang_isDeclaration(Y.kind))
5085     Y.data[1] = nullptr;
5086
5087   return X == Y;
5088 }
5089
5090 unsigned clang_hashCursor(CXCursor C) {
5091   unsigned Index = 0;
5092   if (clang_isExpression(C.kind) || clang_isStatement(C.kind))
5093     Index = 1;
5094
5095   return llvm::DenseMapInfo<std::pair<unsigned, const void*> >::getHashValue(
5096                                         std::make_pair(C.kind, C.data[Index]));
5097 }
5098
5099 unsigned clang_isInvalid(enum CXCursorKind K) {
5100   return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid;
5101 }
5102
5103 unsigned clang_isDeclaration(enum CXCursorKind K) {
5104   return (K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl) ||
5105          (K >= CXCursor_FirstExtraDecl && K <= CXCursor_LastExtraDecl);
5106 }
5107
5108 unsigned clang_isReference(enum CXCursorKind K) {
5109   return K >= CXCursor_FirstRef && K <= CXCursor_LastRef;
5110 }
5111
5112 unsigned clang_isExpression(enum CXCursorKind K) {
5113   return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr;
5114 }
5115
5116 unsigned clang_isStatement(enum CXCursorKind K) {
5117   return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt;
5118 }
5119
5120 unsigned clang_isAttribute(enum CXCursorKind K) {
5121     return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr;
5122 }
5123
5124 unsigned clang_isTranslationUnit(enum CXCursorKind K) {
5125   return K == CXCursor_TranslationUnit;
5126 }
5127
5128 unsigned clang_isPreprocessing(enum CXCursorKind K) {
5129   return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing;
5130 }
5131
5132 unsigned clang_isUnexposed(enum CXCursorKind K) {
5133   switch (K) {
5134     case CXCursor_UnexposedDecl:
5135     case CXCursor_UnexposedExpr:
5136     case CXCursor_UnexposedStmt:
5137     case CXCursor_UnexposedAttr:
5138       return true;
5139     default:
5140       return false;
5141   }
5142 }
5143
5144 CXCursorKind clang_getCursorKind(CXCursor C) {
5145   return C.kind;
5146 }
5147
5148 CXSourceLocation clang_getCursorLocation(CXCursor C) {
5149   if (clang_isReference(C.kind)) {
5150     switch (C.kind) {
5151     case CXCursor_ObjCSuperClassRef: {
5152       std::pair<const ObjCInterfaceDecl *, SourceLocation> P
5153         = getCursorObjCSuperClassRef(C);
5154       return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
5155     }
5156
5157     case CXCursor_ObjCProtocolRef: {
5158       std::pair<const ObjCProtocolDecl *, SourceLocation> P
5159         = getCursorObjCProtocolRef(C);
5160       return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
5161     }
5162
5163     case CXCursor_ObjCClassRef: {
5164       std::pair<const ObjCInterfaceDecl *, SourceLocation> P
5165         = getCursorObjCClassRef(C);
5166       return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
5167     }
5168
5169     case CXCursor_TypeRef: {
5170       std::pair<const TypeDecl *, SourceLocation> P = getCursorTypeRef(C);
5171       return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
5172     }
5173
5174     case CXCursor_TemplateRef: {
5175       std::pair<const TemplateDecl *, SourceLocation> P =
5176           getCursorTemplateRef(C);
5177       return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
5178     }
5179
5180     case CXCursor_NamespaceRef: {
5181       std::pair<const NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C);
5182       return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
5183     }
5184
5185     case CXCursor_MemberRef: {
5186       std::pair<const FieldDecl *, SourceLocation> P = getCursorMemberRef(C);
5187       return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
5188     }
5189
5190     case CXCursor_VariableRef: {
5191       std::pair<const VarDecl *, SourceLocation> P = getCursorVariableRef(C);
5192       return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
5193     }
5194
5195     case CXCursor_CXXBaseSpecifier: {
5196       const CXXBaseSpecifier *BaseSpec = getCursorCXXBaseSpecifier(C);
5197       if (!BaseSpec)
5198         return clang_getNullLocation();
5199
5200       if (TypeSourceInfo *TSInfo = BaseSpec->getTypeSourceInfo())
5201         return cxloc::translateSourceLocation(getCursorContext(C),
5202                                             TSInfo->getTypeLoc().getBeginLoc());
5203
5204       return cxloc::translateSourceLocation(getCursorContext(C),
5205                                         BaseSpec->getLocStart());
5206     }
5207
5208     case CXCursor_LabelRef: {
5209       std::pair<const LabelStmt *, SourceLocation> P = getCursorLabelRef(C);
5210       return cxloc::translateSourceLocation(getCursorContext(C), P.second);
5211     }
5212
5213     case CXCursor_OverloadedDeclRef:
5214       return cxloc::translateSourceLocation(getCursorContext(C),
5215                                           getCursorOverloadedDeclRef(C).second);
5216
5217     default:
5218       // FIXME: Need a way to enumerate all non-reference cases.
5219       llvm_unreachable("Missed a reference kind");
5220     }
5221   }
5222
5223   if (clang_isExpression(C.kind))
5224     return cxloc::translateSourceLocation(getCursorContext(C),
5225                                    getLocationFromExpr(getCursorExpr(C)));
5226
5227   if (clang_isStatement(C.kind))
5228     return cxloc::translateSourceLocation(getCursorContext(C),
5229                                           getCursorStmt(C)->getLocStart());
5230
5231   if (C.kind == CXCursor_PreprocessingDirective) {
5232     SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin();
5233     return cxloc::translateSourceLocation(getCursorContext(C), L);
5234   }
5235
5236   if (C.kind == CXCursor_MacroExpansion) {
5237     SourceLocation L
5238       = cxcursor::getCursorMacroExpansion(C).getSourceRange().getBegin();
5239     return cxloc::translateSourceLocation(getCursorContext(C), L);
5240   }
5241
5242   if (C.kind == CXCursor_MacroDefinition) {
5243     SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation();
5244     return cxloc::translateSourceLocation(getCursorContext(C), L);
5245   }
5246
5247   if (C.kind == CXCursor_InclusionDirective) {
5248     SourceLocation L
5249       = cxcursor::getCursorInclusionDirective(C)->getSourceRange().getBegin();
5250     return cxloc::translateSourceLocation(getCursorContext(C), L);
5251   }
5252
5253   if (clang_isAttribute(C.kind)) {
5254     SourceLocation L
5255       = cxcursor::getCursorAttr(C)->getLocation();
5256     return cxloc::translateSourceLocation(getCursorContext(C), L);
5257   }
5258
5259   if (!clang_isDeclaration(C.kind))
5260     return clang_getNullLocation();
5261
5262   const Decl *D = getCursorDecl(C);
5263   if (!D)
5264     return clang_getNullLocation();
5265
5266   SourceLocation Loc = D->getLocation();
5267   // FIXME: Multiple variables declared in a single declaration
5268   // currently lack the information needed to correctly determine their
5269   // ranges when accounting for the type-specifier.  We use context
5270   // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
5271   // and if so, whether it is the first decl.
5272   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
5273     if (!cxcursor::isFirstInDeclGroup(C))
5274       Loc = VD->getLocation();
5275   }
5276
5277   // For ObjC methods, give the start location of the method name.
5278   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
5279     Loc = MD->getSelectorStartLoc();
5280
5281   return cxloc::translateSourceLocation(getCursorContext(C), Loc);
5282 }
5283
5284 } // end extern "C"
5285
5286 CXCursor cxcursor::getCursor(CXTranslationUnit TU, SourceLocation SLoc) {
5287   assert(TU);
5288
5289   // Guard against an invalid SourceLocation, or we may assert in one
5290   // of the following calls.
5291   if (SLoc.isInvalid())
5292     return clang_getNullCursor();
5293
5294   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
5295
5296   // Translate the given source location to make it point at the beginning of
5297   // the token under the cursor.
5298   SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(),
5299                                     CXXUnit->getASTContext().getLangOpts());
5300
5301   CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound);
5302   if (SLoc.isValid()) {
5303     GetCursorData ResultData(CXXUnit->getSourceManager(), SLoc, Result);
5304     CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData,
5305                             /*VisitPreprocessorLast=*/true,
5306                             /*VisitIncludedEntities=*/false,
5307                             SourceLocation(SLoc));
5308     CursorVis.visitFileRegion();
5309   }
5310
5311   return Result;
5312 }
5313
5314 static SourceRange getRawCursorExtent(CXCursor C) {
5315   if (clang_isReference(C.kind)) {
5316     switch (C.kind) {
5317     case CXCursor_ObjCSuperClassRef:
5318       return  getCursorObjCSuperClassRef(C).second;
5319
5320     case CXCursor_ObjCProtocolRef:
5321       return getCursorObjCProtocolRef(C).second;
5322
5323     case CXCursor_ObjCClassRef:
5324       return getCursorObjCClassRef(C).second;
5325
5326     case CXCursor_TypeRef:
5327       return getCursorTypeRef(C).second;
5328
5329     case CXCursor_TemplateRef:
5330       return getCursorTemplateRef(C).second;
5331
5332     case CXCursor_NamespaceRef:
5333       return getCursorNamespaceRef(C).second;
5334
5335     case CXCursor_MemberRef:
5336       return getCursorMemberRef(C).second;
5337
5338     case CXCursor_CXXBaseSpecifier:
5339       return getCursorCXXBaseSpecifier(C)->getSourceRange();
5340
5341     case CXCursor_LabelRef:
5342       return getCursorLabelRef(C).second;
5343
5344     case CXCursor_OverloadedDeclRef:
5345       return getCursorOverloadedDeclRef(C).second;
5346
5347     case CXCursor_VariableRef:
5348       return getCursorVariableRef(C).second;
5349
5350     default:
5351       // FIXME: Need a way to enumerate all non-reference cases.
5352       llvm_unreachable("Missed a reference kind");
5353     }
5354   }
5355
5356   if (clang_isExpression(C.kind))
5357     return getCursorExpr(C)->getSourceRange();
5358
5359   if (clang_isStatement(C.kind))
5360     return getCursorStmt(C)->getSourceRange();
5361
5362   if (clang_isAttribute(C.kind))
5363     return getCursorAttr(C)->getRange();
5364
5365   if (C.kind == CXCursor_PreprocessingDirective)
5366     return cxcursor::getCursorPreprocessingDirective(C);
5367
5368   if (C.kind == CXCursor_MacroExpansion) {
5369     ASTUnit *TU = getCursorASTUnit(C);
5370     SourceRange Range = cxcursor::getCursorMacroExpansion(C).getSourceRange();
5371     return TU->mapRangeFromPreamble(Range);
5372   }
5373
5374   if (C.kind == CXCursor_MacroDefinition) {
5375     ASTUnit *TU = getCursorASTUnit(C);
5376     SourceRange Range = cxcursor::getCursorMacroDefinition(C)->getSourceRange();
5377     return TU->mapRangeFromPreamble(Range);
5378   }
5379
5380   if (C.kind == CXCursor_InclusionDirective) {
5381     ASTUnit *TU = getCursorASTUnit(C);
5382     SourceRange Range = cxcursor::getCursorInclusionDirective(C)->getSourceRange();
5383     return TU->mapRangeFromPreamble(Range);
5384   }
5385
5386   if (C.kind == CXCursor_TranslationUnit) {
5387     ASTUnit *TU = getCursorASTUnit(C);
5388     FileID MainID = TU->getSourceManager().getMainFileID();
5389     SourceLocation Start = TU->getSourceManager().getLocForStartOfFile(MainID);
5390     SourceLocation End = TU->getSourceManager().getLocForEndOfFile(MainID);
5391     return SourceRange(Start, End);
5392   }
5393
5394   if (clang_isDeclaration(C.kind)) {
5395     const Decl *D = cxcursor::getCursorDecl(C);
5396     if (!D)
5397       return SourceRange();
5398
5399     SourceRange R = D->getSourceRange();
5400     // FIXME: Multiple variables declared in a single declaration
5401     // currently lack the information needed to correctly determine their
5402     // ranges when accounting for the type-specifier.  We use context
5403     // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
5404     // and if so, whether it is the first decl.
5405     if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
5406       if (!cxcursor::isFirstInDeclGroup(C))
5407         R.setBegin(VD->getLocation());
5408     }
5409     return R;
5410   }
5411   return SourceRange();
5412 }
5413
5414 /// \brief Retrieves the "raw" cursor extent, which is then extended to include
5415 /// the decl-specifier-seq for declarations.
5416 static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) {
5417   if (clang_isDeclaration(C.kind)) {
5418     const Decl *D = cxcursor::getCursorDecl(C);
5419     if (!D)
5420       return SourceRange();
5421
5422     SourceRange R = D->getSourceRange();
5423
5424     // Adjust the start of the location for declarations preceded by
5425     // declaration specifiers.
5426     SourceLocation StartLoc;
5427     if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
5428       if (TypeSourceInfo *TI = DD->getTypeSourceInfo())
5429         StartLoc = TI->getTypeLoc().getLocStart();
5430     } else if (const TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) {
5431       if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo())
5432         StartLoc = TI->getTypeLoc().getLocStart();
5433     }
5434
5435     if (StartLoc.isValid() && R.getBegin().isValid() &&
5436         SrcMgr.isBeforeInTranslationUnit(StartLoc, R.getBegin()))
5437       R.setBegin(StartLoc);
5438
5439     // FIXME: Multiple variables declared in a single declaration
5440     // currently lack the information needed to correctly determine their
5441     // ranges when accounting for the type-specifier.  We use context
5442     // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
5443     // and if so, whether it is the first decl.
5444     if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
5445       if (!cxcursor::isFirstInDeclGroup(C))
5446         R.setBegin(VD->getLocation());
5447     }
5448
5449     return R;
5450   }
5451
5452   return getRawCursorExtent(C);
5453 }
5454
5455 extern "C" {
5456
5457 CXSourceRange clang_getCursorExtent(CXCursor C) {
5458   SourceRange R = getRawCursorExtent(C);
5459   if (R.isInvalid())
5460     return clang_getNullRange();
5461
5462   return cxloc::translateSourceRange(getCursorContext(C), R);
5463 }
5464
5465 CXCursor clang_getCursorReferenced(CXCursor C) {
5466   if (clang_isInvalid(C.kind))
5467     return clang_getNullCursor();
5468
5469   CXTranslationUnit tu = getCursorTU(C);
5470   if (clang_isDeclaration(C.kind)) {
5471     const Decl *D = getCursorDecl(C);
5472     if (!D)
5473       return clang_getNullCursor();
5474     if (const UsingDecl *Using = dyn_cast<UsingDecl>(D))
5475       return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu);
5476     if (const ObjCPropertyImplDecl *PropImpl =
5477             dyn_cast<ObjCPropertyImplDecl>(D))
5478       if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
5479         return MakeCXCursor(Property, tu);
5480
5481     return C;
5482   }
5483
5484   if (clang_isExpression(C.kind)) {
5485     const Expr *E = getCursorExpr(C);
5486     const Decl *D = getDeclFromExpr(E);
5487     if (D) {
5488       CXCursor declCursor = MakeCXCursor(D, tu);
5489       declCursor = getSelectorIdentifierCursor(getSelectorIdentifierIndex(C),
5490                                                declCursor);
5491       return declCursor;
5492     }
5493
5494     if (const OverloadExpr *Ovl = dyn_cast_or_null<OverloadExpr>(E))
5495       return MakeCursorOverloadedDeclRef(Ovl, tu);
5496
5497     return clang_getNullCursor();
5498   }
5499
5500   if (clang_isStatement(C.kind)) {
5501     const Stmt *S = getCursorStmt(C);
5502     if (const GotoStmt *Goto = dyn_cast_or_null<GotoStmt>(S))
5503       if (LabelDecl *label = Goto->getLabel())
5504         if (LabelStmt *labelS = label->getStmt())
5505         return MakeCXCursor(labelS, getCursorDecl(C), tu);
5506
5507     return clang_getNullCursor();
5508   }
5509
5510   if (C.kind == CXCursor_MacroExpansion) {
5511     if (const MacroDefinitionRecord *Def =
5512             getCursorMacroExpansion(C).getDefinition())
5513       return MakeMacroDefinitionCursor(Def, tu);
5514   }
5515
5516   if (!clang_isReference(C.kind))
5517     return clang_getNullCursor();
5518
5519   switch (C.kind) {
5520     case CXCursor_ObjCSuperClassRef:
5521       return MakeCXCursor(getCursorObjCSuperClassRef(C).first, tu);
5522
5523     case CXCursor_ObjCProtocolRef: {
5524       const ObjCProtocolDecl *Prot = getCursorObjCProtocolRef(C).first;
5525       if (const ObjCProtocolDecl *Def = Prot->getDefinition())
5526         return MakeCXCursor(Def, tu);
5527
5528       return MakeCXCursor(Prot, tu);
5529     }
5530
5531     case CXCursor_ObjCClassRef: {
5532       const ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
5533       if (const ObjCInterfaceDecl *Def = Class->getDefinition())
5534         return MakeCXCursor(Def, tu);
5535
5536       return MakeCXCursor(Class, tu);
5537     }
5538
5539     case CXCursor_TypeRef:
5540       return MakeCXCursor(getCursorTypeRef(C).first, tu );
5541
5542     case CXCursor_TemplateRef:
5543       return MakeCXCursor(getCursorTemplateRef(C).first, tu );
5544
5545     case CXCursor_NamespaceRef:
5546       return MakeCXCursor(getCursorNamespaceRef(C).first, tu );
5547
5548     case CXCursor_MemberRef:
5549       return MakeCXCursor(getCursorMemberRef(C).first, tu );
5550
5551     case CXCursor_CXXBaseSpecifier: {
5552       const CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C);
5553       return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(),
5554                                                          tu ));
5555     }
5556
5557     case CXCursor_LabelRef:
5558       // FIXME: We end up faking the "parent" declaration here because we
5559       // don't want to make CXCursor larger.
5560       return MakeCXCursor(getCursorLabelRef(C).first,
5561                           cxtu::getASTUnit(tu)->getASTContext()
5562                               .getTranslationUnitDecl(),
5563                           tu);
5564
5565     case CXCursor_OverloadedDeclRef:
5566       return C;
5567
5568     case CXCursor_VariableRef:
5569       return MakeCXCursor(getCursorVariableRef(C).first, tu);
5570
5571     default:
5572       // We would prefer to enumerate all non-reference cursor kinds here.
5573       llvm_unreachable("Unhandled reference cursor kind");
5574   }
5575 }
5576
5577 CXCursor clang_getCursorDefinition(CXCursor C) {
5578   if (clang_isInvalid(C.kind))
5579     return clang_getNullCursor();
5580
5581   CXTranslationUnit TU = getCursorTU(C);
5582
5583   bool WasReference = false;
5584   if (clang_isReference(C.kind) || clang_isExpression(C.kind)) {
5585     C = clang_getCursorReferenced(C);
5586     WasReference = true;
5587   }
5588
5589   if (C.kind == CXCursor_MacroExpansion)
5590     return clang_getCursorReferenced(C);
5591
5592   if (!clang_isDeclaration(C.kind))
5593     return clang_getNullCursor();
5594
5595   const Decl *D = getCursorDecl(C);
5596   if (!D)
5597     return clang_getNullCursor();
5598
5599   switch (D->getKind()) {
5600   // Declaration kinds that don't really separate the notions of
5601   // declaration and definition.
5602   case Decl::Namespace:
5603   case Decl::Typedef:
5604   case Decl::TypeAlias:
5605   case Decl::TypeAliasTemplate:
5606   case Decl::TemplateTypeParm:
5607   case Decl::EnumConstant:
5608   case Decl::Field:
5609   case Decl::MSProperty:
5610   case Decl::IndirectField:
5611   case Decl::ObjCIvar:
5612   case Decl::ObjCAtDefsField:
5613   case Decl::ImplicitParam:
5614   case Decl::ParmVar:
5615   case Decl::NonTypeTemplateParm:
5616   case Decl::TemplateTemplateParm:
5617   case Decl::ObjCCategoryImpl:
5618   case Decl::ObjCImplementation:
5619   case Decl::AccessSpec:
5620   case Decl::LinkageSpec:
5621   case Decl::ObjCPropertyImpl:
5622   case Decl::FileScopeAsm:
5623   case Decl::StaticAssert:
5624   case Decl::Block:
5625   case Decl::Captured:
5626   case Decl::OMPCapturedExpr:
5627   case Decl::Label:  // FIXME: Is this right??
5628   case Decl::ClassScopeFunctionSpecialization:
5629   case Decl::Import:
5630   case Decl::OMPThreadPrivate:
5631   case Decl::OMPDeclareReduction:
5632   case Decl::ObjCTypeParam:
5633   case Decl::BuiltinTemplate:
5634   case Decl::PragmaComment:
5635   case Decl::PragmaDetectMismatch:
5636     return C;
5637
5638   // Declaration kinds that don't make any sense here, but are
5639   // nonetheless harmless.
5640   case Decl::Empty:
5641   case Decl::TranslationUnit:
5642   case Decl::ExternCContext:
5643     break;
5644
5645   // Declaration kinds for which the definition is not resolvable.
5646   case Decl::UnresolvedUsingTypename:
5647   case Decl::UnresolvedUsingValue:
5648     break;
5649
5650   case Decl::UsingDirective:
5651     return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(),
5652                         TU);
5653
5654   case Decl::NamespaceAlias:
5655     return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), TU);
5656
5657   case Decl::Enum:
5658   case Decl::Record:
5659   case Decl::CXXRecord:
5660   case Decl::ClassTemplateSpecialization:
5661   case Decl::ClassTemplatePartialSpecialization:
5662     if (TagDecl *Def = cast<TagDecl>(D)->getDefinition())
5663       return MakeCXCursor(Def, TU);
5664     return clang_getNullCursor();
5665
5666   case Decl::Function:
5667   case Decl::CXXMethod:
5668   case Decl::CXXConstructor:
5669   case Decl::CXXDestructor:
5670   case Decl::CXXConversion: {
5671     const FunctionDecl *Def = nullptr;
5672     if (cast<FunctionDecl>(D)->getBody(Def))
5673       return MakeCXCursor(Def, TU);
5674     return clang_getNullCursor();
5675   }
5676
5677   case Decl::Var:
5678   case Decl::VarTemplateSpecialization:
5679   case Decl::VarTemplatePartialSpecialization: {
5680     // Ask the variable if it has a definition.
5681     if (const VarDecl *Def = cast<VarDecl>(D)->getDefinition())
5682       return MakeCXCursor(Def, TU);
5683     return clang_getNullCursor();
5684   }
5685
5686   case Decl::FunctionTemplate: {
5687     const FunctionDecl *Def = nullptr;
5688     if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def))
5689       return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU);
5690     return clang_getNullCursor();
5691   }
5692
5693   case Decl::ClassTemplate: {
5694     if (RecordDecl *Def = cast<ClassTemplateDecl>(D)->getTemplatedDecl()
5695                                                             ->getDefinition())
5696       return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(),
5697                           TU);
5698     return clang_getNullCursor();
5699   }
5700
5701   case Decl::VarTemplate: {
5702     if (VarDecl *Def =
5703             cast<VarTemplateDecl>(D)->getTemplatedDecl()->getDefinition())
5704       return MakeCXCursor(cast<VarDecl>(Def)->getDescribedVarTemplate(), TU);
5705     return clang_getNullCursor();
5706   }
5707
5708   case Decl::Using:
5709     return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D),
5710                                        D->getLocation(), TU);
5711
5712   case Decl::UsingShadow:
5713   case Decl::ConstructorUsingShadow:
5714     return clang_getCursorDefinition(
5715                        MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(),
5716                                     TU));
5717
5718   case Decl::ObjCMethod: {
5719     const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D);
5720     if (Method->isThisDeclarationADefinition())
5721       return C;
5722
5723     // Dig out the method definition in the associated
5724     // @implementation, if we have it.
5725     // FIXME: The ASTs should make finding the definition easier.
5726     if (const ObjCInterfaceDecl *Class
5727                        = dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext()))
5728       if (ObjCImplementationDecl *ClassImpl = Class->getImplementation())
5729         if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(),
5730                                                   Method->isInstanceMethod()))
5731           if (Def->isThisDeclarationADefinition())
5732             return MakeCXCursor(Def, TU);
5733
5734     return clang_getNullCursor();
5735   }
5736
5737   case Decl::ObjCCategory:
5738     if (ObjCCategoryImplDecl *Impl
5739                                = cast<ObjCCategoryDecl>(D)->getImplementation())
5740       return MakeCXCursor(Impl, TU);
5741     return clang_getNullCursor();
5742
5743   case Decl::ObjCProtocol:
5744     if (const ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(D)->getDefinition())
5745       return MakeCXCursor(Def, TU);
5746     return clang_getNullCursor();
5747
5748   case Decl::ObjCInterface: {
5749     // There are two notions of a "definition" for an Objective-C
5750     // class: the interface and its implementation. When we resolved a
5751     // reference to an Objective-C class, produce the @interface as
5752     // the definition; when we were provided with the interface,
5753     // produce the @implementation as the definition.
5754     const ObjCInterfaceDecl *IFace = cast<ObjCInterfaceDecl>(D);
5755     if (WasReference) {
5756       if (const ObjCInterfaceDecl *Def = IFace->getDefinition())
5757         return MakeCXCursor(Def, TU);
5758     } else if (ObjCImplementationDecl *Impl = IFace->getImplementation())
5759       return MakeCXCursor(Impl, TU);
5760     return clang_getNullCursor();
5761   }
5762
5763   case Decl::ObjCProperty:
5764     // FIXME: We don't really know where to find the
5765     // ObjCPropertyImplDecls that implement this property.
5766     return clang_getNullCursor();
5767
5768   case Decl::ObjCCompatibleAlias:
5769     if (const ObjCInterfaceDecl *Class
5770           = cast<ObjCCompatibleAliasDecl>(D)->getClassInterface())
5771       if (const ObjCInterfaceDecl *Def = Class->getDefinition())
5772         return MakeCXCursor(Def, TU);
5773
5774     return clang_getNullCursor();
5775
5776   case Decl::Friend:
5777     if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl())
5778       return clang_getCursorDefinition(MakeCXCursor(Friend, TU));
5779     return clang_getNullCursor();
5780
5781   case Decl::FriendTemplate:
5782     if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl())
5783       return clang_getCursorDefinition(MakeCXCursor(Friend, TU));
5784     return clang_getNullCursor();
5785   }
5786
5787   return clang_getNullCursor();
5788 }
5789
5790 unsigned clang_isCursorDefinition(CXCursor C) {
5791   if (!clang_isDeclaration(C.kind))
5792     return 0;
5793
5794   return clang_getCursorDefinition(C) == C;
5795 }
5796
5797 CXCursor clang_getCanonicalCursor(CXCursor C) {
5798   if (!clang_isDeclaration(C.kind))
5799     return C;
5800
5801   if (const Decl *D = getCursorDecl(C)) {
5802     if (const ObjCCategoryImplDecl *CatImplD = dyn_cast<ObjCCategoryImplDecl>(D))
5803       if (ObjCCategoryDecl *CatD = CatImplD->getCategoryDecl())
5804         return MakeCXCursor(CatD, getCursorTU(C));
5805
5806     if (const ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
5807       if (const ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
5808         return MakeCXCursor(IFD, getCursorTU(C));
5809
5810     return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C));
5811   }
5812
5813   return C;
5814 }
5815
5816 int clang_Cursor_getObjCSelectorIndex(CXCursor cursor) {
5817   return cxcursor::getSelectorIdentifierIndexAndLoc(cursor).first;
5818 }
5819
5820 unsigned clang_getNumOverloadedDecls(CXCursor C) {
5821   if (C.kind != CXCursor_OverloadedDeclRef)
5822     return 0;
5823
5824   OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
5825   if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
5826     return E->getNumDecls();
5827
5828   if (OverloadedTemplateStorage *S
5829                               = Storage.dyn_cast<OverloadedTemplateStorage*>())
5830     return S->size();
5831
5832   const Decl *D = Storage.get<const Decl *>();
5833   if (const UsingDecl *Using = dyn_cast<UsingDecl>(D))
5834     return Using->shadow_size();
5835
5836   return 0;
5837 }
5838
5839 CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) {
5840   if (cursor.kind != CXCursor_OverloadedDeclRef)
5841     return clang_getNullCursor();
5842
5843   if (index >= clang_getNumOverloadedDecls(cursor))
5844     return clang_getNullCursor();
5845
5846   CXTranslationUnit TU = getCursorTU(cursor);
5847   OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first;
5848   if (const OverloadExpr *E = Storage.dyn_cast<const OverloadExpr *>())
5849     return MakeCXCursor(E->decls_begin()[index], TU);
5850
5851   if (OverloadedTemplateStorage *S
5852                               = Storage.dyn_cast<OverloadedTemplateStorage*>())
5853     return MakeCXCursor(S->begin()[index], TU);
5854
5855   const Decl *D = Storage.get<const Decl *>();
5856   if (const UsingDecl *Using = dyn_cast<UsingDecl>(D)) {
5857     // FIXME: This is, unfortunately, linear time.
5858     UsingDecl::shadow_iterator Pos = Using->shadow_begin();
5859     std::advance(Pos, index);
5860     return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU);
5861   }
5862
5863   return clang_getNullCursor();
5864 }
5865
5866 void clang_getDefinitionSpellingAndExtent(CXCursor C,
5867                                           const char **startBuf,
5868                                           const char **endBuf,
5869                                           unsigned *startLine,
5870                                           unsigned *startColumn,
5871                                           unsigned *endLine,
5872                                           unsigned *endColumn) {
5873   assert(getCursorDecl(C) && "CXCursor has null decl");
5874   const FunctionDecl *FD = dyn_cast<FunctionDecl>(getCursorDecl(C));
5875   CompoundStmt *Body = dyn_cast<CompoundStmt>(FD->getBody());
5876
5877   SourceManager &SM = FD->getASTContext().getSourceManager();
5878   *startBuf = SM.getCharacterData(Body->getLBracLoc());
5879   *endBuf = SM.getCharacterData(Body->getRBracLoc());
5880   *startLine = SM.getSpellingLineNumber(Body->getLBracLoc());
5881   *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc());
5882   *endLine = SM.getSpellingLineNumber(Body->getRBracLoc());
5883   *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc());
5884 }
5885
5886
5887 CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags,
5888                                                 unsigned PieceIndex) {
5889   RefNamePieces Pieces;
5890
5891   switch (C.kind) {
5892   case CXCursor_MemberRefExpr:
5893     if (const MemberExpr *E = dyn_cast<MemberExpr>(getCursorExpr(C)))
5894       Pieces = buildPieces(NameFlags, true, E->getMemberNameInfo(),
5895                            E->getQualifierLoc().getSourceRange());
5896     break;
5897
5898   case CXCursor_DeclRefExpr:
5899     if (const DeclRefExpr *E = dyn_cast<DeclRefExpr>(getCursorExpr(C))) {
5900       SourceRange TemplateArgLoc(E->getLAngleLoc(), E->getRAngleLoc());
5901       Pieces =
5902           buildPieces(NameFlags, false, E->getNameInfo(),
5903                       E->getQualifierLoc().getSourceRange(), &TemplateArgLoc);
5904     }
5905     break;
5906
5907   case CXCursor_CallExpr:
5908     if (const CXXOperatorCallExpr *OCE =
5909         dyn_cast<CXXOperatorCallExpr>(getCursorExpr(C))) {
5910       const Expr *Callee = OCE->getCallee();
5911       if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee))
5912         Callee = ICE->getSubExpr();
5913
5914       if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee))
5915         Pieces = buildPieces(NameFlags, false, DRE->getNameInfo(),
5916                              DRE->getQualifierLoc().getSourceRange());
5917     }
5918     break;
5919
5920   default:
5921     break;
5922   }
5923
5924   if (Pieces.empty()) {
5925     if (PieceIndex == 0)
5926       return clang_getCursorExtent(C);
5927   } else if (PieceIndex < Pieces.size()) {
5928       SourceRange R = Pieces[PieceIndex];
5929       if (R.isValid())
5930         return cxloc::translateSourceRange(getCursorContext(C), R);
5931   }
5932
5933   return clang_getNullRange();
5934 }
5935
5936 void clang_enableStackTraces(void) {
5937   // FIXME: Provide an argv0 here so we can find llvm-symbolizer.
5938   llvm::sys::PrintStackTraceOnErrorSignal(StringRef());
5939 }
5940
5941 void clang_executeOnThread(void (*fn)(void*), void *user_data,
5942                            unsigned stack_size) {
5943   llvm::llvm_execute_on_thread(fn, user_data, stack_size);
5944 }
5945
5946 } // end: extern "C"
5947
5948 //===----------------------------------------------------------------------===//
5949 // Token-based Operations.
5950 //===----------------------------------------------------------------------===//
5951
5952 /* CXToken layout:
5953  *   int_data[0]: a CXTokenKind
5954  *   int_data[1]: starting token location
5955  *   int_data[2]: token length
5956  *   int_data[3]: reserved
5957  *   ptr_data: for identifiers and keywords, an IdentifierInfo*.
5958  *   otherwise unused.
5959  */
5960 extern "C" {
5961
5962 CXTokenKind clang_getTokenKind(CXToken CXTok) {
5963   return static_cast<CXTokenKind>(CXTok.int_data[0]);
5964 }
5965
5966 CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) {
5967   switch (clang_getTokenKind(CXTok)) {
5968   case CXToken_Identifier:
5969   case CXToken_Keyword:
5970     // We know we have an IdentifierInfo*, so use that.
5971     return cxstring::createRef(static_cast<IdentifierInfo *>(CXTok.ptr_data)
5972                             ->getNameStart());
5973
5974   case CXToken_Literal: {
5975     // We have stashed the starting pointer in the ptr_data field. Use it.
5976     const char *Text = static_cast<const char *>(CXTok.ptr_data);
5977     return cxstring::createDup(StringRef(Text, CXTok.int_data[2]));
5978   }
5979
5980   case CXToken_Punctuation:
5981   case CXToken_Comment:
5982     break;
5983   }
5984
5985   if (isNotUsableTU(TU)) {
5986     LOG_BAD_TU(TU);
5987     return cxstring::createEmpty();
5988   }
5989
5990   // We have to find the starting buffer pointer the hard way, by
5991   // deconstructing the source location.
5992   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
5993   if (!CXXUnit)
5994     return cxstring::createEmpty();
5995
5996   SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]);
5997   std::pair<FileID, unsigned> LocInfo
5998     = CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc);
5999   bool Invalid = false;
6000   StringRef Buffer
6001     = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid);
6002   if (Invalid)
6003     return cxstring::createEmpty();
6004
6005   return cxstring::createDup(Buffer.substr(LocInfo.second, CXTok.int_data[2]));
6006 }
6007
6008 CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) {
6009   if (isNotUsableTU(TU)) {
6010     LOG_BAD_TU(TU);
6011     return clang_getNullLocation();
6012   }
6013
6014   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
6015   if (!CXXUnit)
6016     return clang_getNullLocation();
6017
6018   return cxloc::translateSourceLocation(CXXUnit->getASTContext(),
6019                         SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
6020 }
6021
6022 CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) {
6023   if (isNotUsableTU(TU)) {
6024     LOG_BAD_TU(TU);
6025     return clang_getNullRange();
6026   }
6027
6028   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
6029   if (!CXXUnit)
6030     return clang_getNullRange();
6031
6032   return cxloc::translateSourceRange(CXXUnit->getASTContext(),
6033                         SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
6034 }
6035
6036 static void getTokens(ASTUnit *CXXUnit, SourceRange Range,
6037                       SmallVectorImpl<CXToken> &CXTokens) {
6038   SourceManager &SourceMgr = CXXUnit->getSourceManager();
6039   std::pair<FileID, unsigned> BeginLocInfo
6040     = SourceMgr.getDecomposedSpellingLoc(Range.getBegin());
6041   std::pair<FileID, unsigned> EndLocInfo
6042     = SourceMgr.getDecomposedSpellingLoc(Range.getEnd());
6043
6044   // Cannot tokenize across files.
6045   if (BeginLocInfo.first != EndLocInfo.first)
6046     return;
6047
6048   // Create a lexer
6049   bool Invalid = false;
6050   StringRef Buffer
6051     = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
6052   if (Invalid)
6053     return;
6054
6055   Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
6056             CXXUnit->getASTContext().getLangOpts(),
6057             Buffer.begin(), Buffer.data() + BeginLocInfo.second, Buffer.end());
6058   Lex.SetCommentRetentionState(true);
6059
6060   // Lex tokens until we hit the end of the range.
6061   const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second;
6062   Token Tok;
6063   bool previousWasAt = false;
6064   do {
6065     // Lex the next token
6066     Lex.LexFromRawLexer(Tok);
6067     if (Tok.is(tok::eof))
6068       break;
6069
6070     // Initialize the CXToken.
6071     CXToken CXTok;
6072
6073     //   - Common fields
6074     CXTok.int_data[1] = Tok.getLocation().getRawEncoding();
6075     CXTok.int_data[2] = Tok.getLength();
6076     CXTok.int_data[3] = 0;
6077
6078     //   - Kind-specific fields
6079     if (Tok.isLiteral()) {
6080       CXTok.int_data[0] = CXToken_Literal;
6081       CXTok.ptr_data = const_cast<char *>(Tok.getLiteralData());
6082     } else if (Tok.is(tok::raw_identifier)) {
6083       // Lookup the identifier to determine whether we have a keyword.
6084       IdentifierInfo *II
6085         = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok);
6086
6087       if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) {
6088         CXTok.int_data[0] = CXToken_Keyword;
6089       }
6090       else {
6091         CXTok.int_data[0] = Tok.is(tok::identifier)
6092           ? CXToken_Identifier
6093           : CXToken_Keyword;
6094       }
6095       CXTok.ptr_data = II;
6096     } else if (Tok.is(tok::comment)) {
6097       CXTok.int_data[0] = CXToken_Comment;
6098       CXTok.ptr_data = nullptr;
6099     } else {
6100       CXTok.int_data[0] = CXToken_Punctuation;
6101       CXTok.ptr_data = nullptr;
6102     }
6103     CXTokens.push_back(CXTok);
6104     previousWasAt = Tok.is(tok::at);
6105   } while (Lex.getBufferLocation() <= EffectiveBufferEnd);
6106 }
6107
6108 void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range,
6109                     CXToken **Tokens, unsigned *NumTokens) {
6110   LOG_FUNC_SECTION {
6111     *Log << TU << ' ' << Range;
6112   }
6113
6114   if (Tokens)
6115     *Tokens = nullptr;
6116   if (NumTokens)
6117     *NumTokens = 0;
6118
6119   if (isNotUsableTU(TU)) {
6120     LOG_BAD_TU(TU);
6121     return;
6122   }
6123
6124   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
6125   if (!CXXUnit || !Tokens || !NumTokens)
6126     return;
6127
6128   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
6129
6130   SourceRange R = cxloc::translateCXSourceRange(Range);
6131   if (R.isInvalid())
6132     return;
6133
6134   SmallVector<CXToken, 32> CXTokens;
6135   getTokens(CXXUnit, R, CXTokens);
6136
6137   if (CXTokens.empty())
6138     return;
6139
6140   *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size());
6141   memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size());
6142   *NumTokens = CXTokens.size();
6143 }
6144
6145 void clang_disposeTokens(CXTranslationUnit TU,
6146                          CXToken *Tokens, unsigned NumTokens) {
6147   free(Tokens);
6148 }
6149
6150 } // end: extern "C"
6151
6152 //===----------------------------------------------------------------------===//
6153 // Token annotation APIs.
6154 //===----------------------------------------------------------------------===//
6155
6156 static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
6157                                                      CXCursor parent,
6158                                                      CXClientData client_data);
6159 static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor,
6160                                               CXClientData client_data);
6161
6162 namespace {
6163 class AnnotateTokensWorker {
6164   CXToken *Tokens;
6165   CXCursor *Cursors;
6166   unsigned NumTokens;
6167   unsigned TokIdx;
6168   unsigned PreprocessingTokIdx;
6169   CursorVisitor AnnotateVis;
6170   SourceManager &SrcMgr;
6171   bool HasContextSensitiveKeywords;
6172
6173   struct PostChildrenInfo {
6174     CXCursor Cursor;
6175     SourceRange CursorRange;
6176     unsigned BeforeReachingCursorIdx;
6177     unsigned BeforeChildrenTokenIdx;
6178   };
6179   SmallVector<PostChildrenInfo, 8> PostChildrenInfos;
6180
6181   CXToken &getTok(unsigned Idx) {
6182     assert(Idx < NumTokens);
6183     return Tokens[Idx];
6184   }
6185   const CXToken &getTok(unsigned Idx) const {
6186     assert(Idx < NumTokens);
6187     return Tokens[Idx];
6188   }
6189   bool MoreTokens() const { return TokIdx < NumTokens; }
6190   unsigned NextToken() const { return TokIdx; }
6191   void AdvanceToken() { ++TokIdx; }
6192   SourceLocation GetTokenLoc(unsigned tokI) {
6193     return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]);
6194   }
6195   bool isFunctionMacroToken(unsigned tokI) const {
6196     return getTok(tokI).int_data[3] != 0;
6197   }
6198   SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const {
6199     return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[3]);
6200   }
6201
6202   void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange);
6203   bool annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult,
6204                                              SourceRange);
6205
6206 public:
6207   AnnotateTokensWorker(CXToken *tokens, CXCursor *cursors, unsigned numTokens,
6208                        CXTranslationUnit TU, SourceRange RegionOfInterest)
6209     : Tokens(tokens), Cursors(cursors),
6210       NumTokens(numTokens), TokIdx(0), PreprocessingTokIdx(0),
6211       AnnotateVis(TU,
6212                   AnnotateTokensVisitor, this,
6213                   /*VisitPreprocessorLast=*/true,
6214                   /*VisitIncludedEntities=*/false,
6215                   RegionOfInterest,
6216                   /*VisitDeclsOnly=*/false,
6217                   AnnotateTokensPostChildrenVisitor),
6218       SrcMgr(cxtu::getASTUnit(TU)->getSourceManager()),
6219       HasContextSensitiveKeywords(false) { }
6220
6221   void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); }
6222   enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent);
6223   bool postVisitChildren(CXCursor cursor);
6224   void AnnotateTokens();
6225
6226   /// \brief Determine whether the annotator saw any cursors that have
6227   /// context-sensitive keywords.
6228   bool hasContextSensitiveKeywords() const {
6229     return HasContextSensitiveKeywords;
6230   }
6231
6232   ~AnnotateTokensWorker() {
6233     assert(PostChildrenInfos.empty());
6234   }
6235 };
6236 }
6237
6238 void AnnotateTokensWorker::AnnotateTokens() {
6239   // Walk the AST within the region of interest, annotating tokens
6240   // along the way.
6241   AnnotateVis.visitFileRegion();
6242 }
6243
6244 static inline void updateCursorAnnotation(CXCursor &Cursor,
6245                                           const CXCursor &updateC) {
6246   if (clang_isInvalid(updateC.kind) || !clang_isInvalid(Cursor.kind))
6247     return;
6248   Cursor = updateC;
6249 }
6250
6251 /// \brief It annotates and advances tokens with a cursor until the comparison
6252 //// between the cursor location and the source range is the same as
6253 /// \arg compResult.
6254 ///
6255 /// Pass RangeBefore to annotate tokens with a cursor until a range is reached.
6256 /// Pass RangeOverlap to annotate tokens inside a range.
6257 void AnnotateTokensWorker::annotateAndAdvanceTokens(CXCursor updateC,
6258                                                RangeComparisonResult compResult,
6259                                                SourceRange range) {
6260   while (MoreTokens()) {
6261     const unsigned I = NextToken();
6262     if (isFunctionMacroToken(I))
6263       if (!annotateAndAdvanceFunctionMacroTokens(updateC, compResult, range))
6264         return;
6265
6266     SourceLocation TokLoc = GetTokenLoc(I);
6267     if (LocationCompare(SrcMgr, TokLoc, range) == compResult) {
6268       updateCursorAnnotation(Cursors[I], updateC);
6269       AdvanceToken();
6270       continue;
6271     }
6272     break;
6273   }
6274 }
6275
6276 /// \brief Special annotation handling for macro argument tokens.
6277 /// \returns true if it advanced beyond all macro tokens, false otherwise.
6278 bool AnnotateTokensWorker::annotateAndAdvanceFunctionMacroTokens(
6279                                                CXCursor updateC,
6280                                                RangeComparisonResult compResult,
6281                                                SourceRange range) {
6282   assert(MoreTokens());
6283   assert(isFunctionMacroToken(NextToken()) &&
6284          "Should be called only for macro arg tokens");
6285
6286   // This works differently than annotateAndAdvanceTokens; because expanded
6287   // macro arguments can have arbitrary translation-unit source order, we do not
6288   // advance the token index one by one until a token fails the range test.
6289   // We only advance once past all of the macro arg tokens if all of them
6290   // pass the range test. If one of them fails we keep the token index pointing
6291   // at the start of the macro arg tokens so that the failing token will be
6292   // annotated by a subsequent annotation try.
6293
6294   bool atLeastOneCompFail = false;
6295
6296   unsigned I = NextToken();
6297   for (; I < NumTokens && isFunctionMacroToken(I); ++I) {
6298     SourceLocation TokLoc = getFunctionMacroTokenLoc(I);
6299     if (TokLoc.isFileID())
6300       continue; // not macro arg token, it's parens or comma.
6301     if (LocationCompare(SrcMgr, TokLoc, range) == compResult) {
6302       if (clang_isInvalid(clang_getCursorKind(Cursors[I])))
6303         Cursors[I] = updateC;
6304     } else
6305       atLeastOneCompFail = true;
6306   }
6307
6308   if (atLeastOneCompFail)
6309     return false;
6310
6311   TokIdx = I; // All of the tokens were handled, advance beyond all of them.
6312   return true;
6313 }
6314
6315 enum CXChildVisitResult
6316 AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) {
6317   SourceRange cursorRange = getRawCursorExtent(cursor);
6318   if (cursorRange.isInvalid())
6319     return CXChildVisit_Recurse;
6320
6321   if (!HasContextSensitiveKeywords) {
6322     // Objective-C properties can have context-sensitive keywords.
6323     if (cursor.kind == CXCursor_ObjCPropertyDecl) {
6324       if (const ObjCPropertyDecl *Property
6325                   = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(cursor)))
6326         HasContextSensitiveKeywords = Property->getPropertyAttributesAsWritten() != 0;
6327     }
6328     // Objective-C methods can have context-sensitive keywords.
6329     else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl ||
6330              cursor.kind == CXCursor_ObjCClassMethodDecl) {
6331       if (const ObjCMethodDecl *Method
6332             = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) {
6333         if (Method->getObjCDeclQualifier())
6334           HasContextSensitiveKeywords = true;
6335         else {
6336           for (const auto *P : Method->parameters()) {
6337             if (P->getObjCDeclQualifier()) {
6338               HasContextSensitiveKeywords = true;
6339               break;
6340             }
6341           }
6342         }
6343       }
6344     }
6345     // C++ methods can have context-sensitive keywords.
6346     else if (cursor.kind == CXCursor_CXXMethod) {
6347       if (const CXXMethodDecl *Method
6348                   = dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(cursor))) {
6349         if (Method->hasAttr<FinalAttr>() || Method->hasAttr<OverrideAttr>())
6350           HasContextSensitiveKeywords = true;
6351       }
6352     }
6353     // C++ classes can have context-sensitive keywords.
6354     else if (cursor.kind == CXCursor_StructDecl ||
6355              cursor.kind == CXCursor_ClassDecl ||
6356              cursor.kind == CXCursor_ClassTemplate ||
6357              cursor.kind == CXCursor_ClassTemplatePartialSpecialization) {
6358       if (const Decl *D = getCursorDecl(cursor))
6359         if (D->hasAttr<FinalAttr>())
6360           HasContextSensitiveKeywords = true;
6361     }
6362   }
6363
6364   // Don't override a property annotation with its getter/setter method.
6365   if (cursor.kind == CXCursor_ObjCInstanceMethodDecl &&
6366       parent.kind == CXCursor_ObjCPropertyDecl)
6367     return CXChildVisit_Continue;
6368
6369   if (clang_isPreprocessing(cursor.kind)) {
6370     // Items in the preprocessing record are kept separate from items in
6371     // declarations, so we keep a separate token index.
6372     unsigned SavedTokIdx = TokIdx;
6373     TokIdx = PreprocessingTokIdx;
6374
6375     // Skip tokens up until we catch up to the beginning of the preprocessing
6376     // entry.
6377     while (MoreTokens()) {
6378       const unsigned I = NextToken();
6379       SourceLocation TokLoc = GetTokenLoc(I);
6380       switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
6381       case RangeBefore:
6382         AdvanceToken();
6383         continue;
6384       case RangeAfter:
6385       case RangeOverlap:
6386         break;
6387       }
6388       break;
6389     }
6390
6391     // Look at all of the tokens within this range.
6392     while (MoreTokens()) {
6393       const unsigned I = NextToken();
6394       SourceLocation TokLoc = GetTokenLoc(I);
6395       switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
6396       case RangeBefore:
6397         llvm_unreachable("Infeasible");
6398       case RangeAfter:
6399         break;
6400       case RangeOverlap:
6401         // For macro expansions, just note where the beginning of the macro
6402         // expansion occurs.
6403         if (cursor.kind == CXCursor_MacroExpansion) {
6404           if (TokLoc == cursorRange.getBegin())
6405             Cursors[I] = cursor;
6406           AdvanceToken();
6407           break;
6408         }
6409         // We may have already annotated macro names inside macro definitions.
6410         if (Cursors[I].kind != CXCursor_MacroExpansion)
6411           Cursors[I] = cursor;
6412         AdvanceToken();
6413         continue;
6414       }
6415       break;
6416     }
6417
6418     // Save the preprocessing token index; restore the non-preprocessing
6419     // token index.
6420     PreprocessingTokIdx = TokIdx;
6421     TokIdx = SavedTokIdx;
6422     return CXChildVisit_Recurse;
6423   }
6424
6425   if (cursorRange.isInvalid())
6426     return CXChildVisit_Continue;
6427
6428   unsigned BeforeReachingCursorIdx = NextToken();
6429   const enum CXCursorKind cursorK = clang_getCursorKind(cursor);
6430   const enum CXCursorKind K = clang_getCursorKind(parent);
6431   const CXCursor updateC =
6432     (clang_isInvalid(K) || K == CXCursor_TranslationUnit ||
6433      // Attributes are annotated out-of-order, skip tokens until we reach it.
6434      clang_isAttribute(cursor.kind))
6435      ? clang_getNullCursor() : parent;
6436
6437   annotateAndAdvanceTokens(updateC, RangeBefore, cursorRange);
6438
6439   // Avoid having the cursor of an expression "overwrite" the annotation of the
6440   // variable declaration that it belongs to.
6441   // This can happen for C++ constructor expressions whose range generally
6442   // include the variable declaration, e.g.:
6443   //  MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor.
6444   if (clang_isExpression(cursorK) && MoreTokens()) {
6445     const Expr *E = getCursorExpr(cursor);
6446     if (const Decl *D = getCursorParentDecl(cursor)) {
6447       const unsigned I = NextToken();
6448       if (E->getLocStart().isValid() && D->getLocation().isValid() &&
6449           E->getLocStart() == D->getLocation() &&
6450           E->getLocStart() == GetTokenLoc(I)) {
6451         updateCursorAnnotation(Cursors[I], updateC);
6452         AdvanceToken();
6453       }
6454     }
6455   }
6456
6457   // Before recursing into the children keep some state that we are going
6458   // to use in the AnnotateTokensWorker::postVisitChildren callback to do some
6459   // extra work after the child nodes are visited.
6460   // Note that we don't call VisitChildren here to avoid traversing statements
6461   // code-recursively which can blow the stack.
6462
6463   PostChildrenInfo Info;
6464   Info.Cursor = cursor;
6465   Info.CursorRange = cursorRange;
6466   Info.BeforeReachingCursorIdx = BeforeReachingCursorIdx;
6467   Info.BeforeChildrenTokenIdx = NextToken();
6468   PostChildrenInfos.push_back(Info);
6469
6470   return CXChildVisit_Recurse;
6471 }
6472
6473 bool AnnotateTokensWorker::postVisitChildren(CXCursor cursor) {
6474   if (PostChildrenInfos.empty())
6475     return false;
6476   const PostChildrenInfo &Info = PostChildrenInfos.back();
6477   if (!clang_equalCursors(Info.Cursor, cursor))
6478     return false;
6479
6480   const unsigned BeforeChildren = Info.BeforeChildrenTokenIdx;
6481   const unsigned AfterChildren = NextToken();
6482   SourceRange cursorRange = Info.CursorRange;
6483
6484   // Scan the tokens that are at the end of the cursor, but are not captured
6485   // but the child cursors.
6486   annotateAndAdvanceTokens(cursor, RangeOverlap, cursorRange);
6487
6488   // Scan the tokens that are at the beginning of the cursor, but are not
6489   // capture by the child cursors.
6490   for (unsigned I = BeforeChildren; I != AfterChildren; ++I) {
6491     if (!clang_isInvalid(clang_getCursorKind(Cursors[I])))
6492       break;
6493
6494     Cursors[I] = cursor;
6495   }
6496
6497   // Attributes are annotated out-of-order, rewind TokIdx to when we first
6498   // encountered the attribute cursor.
6499   if (clang_isAttribute(cursor.kind))
6500     TokIdx = Info.BeforeReachingCursorIdx;
6501
6502   PostChildrenInfos.pop_back();
6503   return false;
6504 }
6505
6506 static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
6507                                                      CXCursor parent,
6508                                                      CXClientData client_data) {
6509   return static_cast<AnnotateTokensWorker*>(client_data)->Visit(cursor, parent);
6510 }
6511
6512 static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor,
6513                                               CXClientData client_data) {
6514   return static_cast<AnnotateTokensWorker*>(client_data)->
6515                                                       postVisitChildren(cursor);
6516 }
6517
6518 namespace {
6519
6520 /// \brief Uses the macro expansions in the preprocessing record to find
6521 /// and mark tokens that are macro arguments. This info is used by the
6522 /// AnnotateTokensWorker.
6523 class MarkMacroArgTokensVisitor {
6524   SourceManager &SM;
6525   CXToken *Tokens;
6526   unsigned NumTokens;
6527   unsigned CurIdx;
6528
6529 public:
6530   MarkMacroArgTokensVisitor(SourceManager &SM,
6531                             CXToken *tokens, unsigned numTokens)
6532     : SM(SM), Tokens(tokens), NumTokens(numTokens), CurIdx(0) { }
6533
6534   CXChildVisitResult visit(CXCursor cursor, CXCursor parent) {
6535     if (cursor.kind != CXCursor_MacroExpansion)
6536       return CXChildVisit_Continue;
6537
6538     SourceRange macroRange = getCursorMacroExpansion(cursor).getSourceRange();
6539     if (macroRange.getBegin() == macroRange.getEnd())
6540       return CXChildVisit_Continue; // it's not a function macro.
6541
6542     for (; CurIdx < NumTokens; ++CurIdx) {
6543       if (!SM.isBeforeInTranslationUnit(getTokenLoc(CurIdx),
6544                                         macroRange.getBegin()))
6545         break;
6546     }
6547
6548     if (CurIdx == NumTokens)
6549       return CXChildVisit_Break;
6550
6551     for (; CurIdx < NumTokens; ++CurIdx) {
6552       SourceLocation tokLoc = getTokenLoc(CurIdx);
6553       if (!SM.isBeforeInTranslationUnit(tokLoc, macroRange.getEnd()))
6554         break;
6555
6556       setFunctionMacroTokenLoc(CurIdx, SM.getMacroArgExpandedLocation(tokLoc));
6557     }
6558
6559     if (CurIdx == NumTokens)
6560       return CXChildVisit_Break;
6561
6562     return CXChildVisit_Continue;
6563   }
6564
6565 private:
6566   CXToken &getTok(unsigned Idx) {
6567     assert(Idx < NumTokens);
6568     return Tokens[Idx];
6569   }
6570   const CXToken &getTok(unsigned Idx) const {
6571     assert(Idx < NumTokens);
6572     return Tokens[Idx];
6573   }
6574
6575   SourceLocation getTokenLoc(unsigned tokI) {
6576     return SourceLocation::getFromRawEncoding(getTok(tokI).int_data[1]);
6577   }
6578
6579   void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) {
6580     // The third field is reserved and currently not used. Use it here
6581     // to mark macro arg expanded tokens with their expanded locations.
6582     getTok(tokI).int_data[3] = loc.getRawEncoding();
6583   }
6584 };
6585
6586 } // end anonymous namespace
6587
6588 static CXChildVisitResult
6589 MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent,
6590                                   CXClientData client_data) {
6591   return static_cast<MarkMacroArgTokensVisitor*>(client_data)->visit(cursor,
6592                                                                      parent);
6593 }
6594
6595 /// \brief Used by \c annotatePreprocessorTokens.
6596 /// \returns true if lexing was finished, false otherwise.
6597 static bool lexNext(Lexer &Lex, Token &Tok,
6598                    unsigned &NextIdx, unsigned NumTokens) {
6599   if (NextIdx >= NumTokens)
6600     return true;
6601
6602   ++NextIdx;
6603   Lex.LexFromRawLexer(Tok);
6604   return Tok.is(tok::eof);
6605 }
6606
6607 static void annotatePreprocessorTokens(CXTranslationUnit TU,
6608                                        SourceRange RegionOfInterest,
6609                                        CXCursor *Cursors,
6610                                        CXToken *Tokens,
6611                                        unsigned NumTokens) {
6612   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
6613
6614   Preprocessor &PP = CXXUnit->getPreprocessor();
6615   SourceManager &SourceMgr = CXXUnit->getSourceManager();
6616   std::pair<FileID, unsigned> BeginLocInfo
6617     = SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getBegin());
6618   std::pair<FileID, unsigned> EndLocInfo
6619     = SourceMgr.getDecomposedSpellingLoc(RegionOfInterest.getEnd());
6620
6621   if (BeginLocInfo.first != EndLocInfo.first)
6622     return;
6623
6624   StringRef Buffer;
6625   bool Invalid = false;
6626   Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
6627   if (Buffer.empty() || Invalid)
6628     return;
6629
6630   Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
6631             CXXUnit->getASTContext().getLangOpts(),
6632             Buffer.begin(), Buffer.data() + BeginLocInfo.second,
6633             Buffer.end());
6634   Lex.SetCommentRetentionState(true);
6635
6636   unsigned NextIdx = 0;
6637   // Lex tokens in raw mode until we hit the end of the range, to avoid
6638   // entering #includes or expanding macros.
6639   while (true) {
6640     Token Tok;
6641     if (lexNext(Lex, Tok, NextIdx, NumTokens))
6642       break;
6643     unsigned TokIdx = NextIdx-1;
6644     assert(Tok.getLocation() ==
6645              SourceLocation::getFromRawEncoding(Tokens[TokIdx].int_data[1]));
6646
6647   reprocess:
6648     if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) {
6649       // We have found a preprocessing directive. Annotate the tokens
6650       // appropriately.
6651       //
6652       // FIXME: Some simple tests here could identify macro definitions and
6653       // #undefs, to provide specific cursor kinds for those.
6654
6655       SourceLocation BeginLoc = Tok.getLocation();
6656       if (lexNext(Lex, Tok, NextIdx, NumTokens))
6657         break;
6658
6659       MacroInfo *MI = nullptr;
6660       if (Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == "define") {
6661         if (lexNext(Lex, Tok, NextIdx, NumTokens))
6662           break;
6663
6664         if (Tok.is(tok::raw_identifier)) {
6665           IdentifierInfo &II =
6666               PP.getIdentifierTable().get(Tok.getRawIdentifier());
6667           SourceLocation MappedTokLoc =
6668               CXXUnit->mapLocationToPreamble(Tok.getLocation());
6669           MI = getMacroInfo(II, MappedTokLoc, TU);
6670         }
6671       }
6672
6673       bool finished = false;
6674       do {
6675         if (lexNext(Lex, Tok, NextIdx, NumTokens)) {
6676           finished = true;
6677           break;
6678         }
6679         // If we are in a macro definition, check if the token was ever a
6680         // macro name and annotate it if that's the case.
6681         if (MI) {
6682           SourceLocation SaveLoc = Tok.getLocation();
6683           Tok.setLocation(CXXUnit->mapLocationToPreamble(SaveLoc));
6684           MacroDefinitionRecord *MacroDef =
6685               checkForMacroInMacroDefinition(MI, Tok, TU);
6686           Tok.setLocation(SaveLoc);
6687           if (MacroDef)
6688             Cursors[NextIdx - 1] =
6689                 MakeMacroExpansionCursor(MacroDef, Tok.getLocation(), TU);
6690         }
6691       } while (!Tok.isAtStartOfLine());
6692
6693       unsigned LastIdx = finished ? NextIdx-1 : NextIdx-2;
6694       assert(TokIdx <= LastIdx);
6695       SourceLocation EndLoc =
6696           SourceLocation::getFromRawEncoding(Tokens[LastIdx].int_data[1]);
6697       CXCursor Cursor =
6698           MakePreprocessingDirectiveCursor(SourceRange(BeginLoc, EndLoc), TU);
6699
6700       for (; TokIdx <= LastIdx; ++TokIdx)
6701         updateCursorAnnotation(Cursors[TokIdx], Cursor);
6702
6703       if (finished)
6704         break;
6705       goto reprocess;
6706     }
6707   }
6708 }
6709
6710 // This gets run a separate thread to avoid stack blowout.
6711 static void clang_annotateTokensImpl(CXTranslationUnit TU, ASTUnit *CXXUnit,
6712                                      CXToken *Tokens, unsigned NumTokens,
6713                                      CXCursor *Cursors) {
6714   CIndexer *CXXIdx = TU->CIdx;
6715   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
6716     setThreadBackgroundPriority();
6717
6718   // Determine the region of interest, which contains all of the tokens.
6719   SourceRange RegionOfInterest;
6720   RegionOfInterest.setBegin(
6721     cxloc::translateSourceLocation(clang_getTokenLocation(TU, Tokens[0])));
6722   RegionOfInterest.setEnd(
6723     cxloc::translateSourceLocation(clang_getTokenLocation(TU,
6724                                                          Tokens[NumTokens-1])));
6725
6726   // Relex the tokens within the source range to look for preprocessing
6727   // directives.
6728   annotatePreprocessorTokens(TU, RegionOfInterest, Cursors, Tokens, NumTokens);
6729
6730   // If begin location points inside a macro argument, set it to the expansion
6731   // location so we can have the full context when annotating semantically.
6732   {
6733     SourceManager &SM = CXXUnit->getSourceManager();
6734     SourceLocation Loc =
6735         SM.getMacroArgExpandedLocation(RegionOfInterest.getBegin());
6736     if (Loc.isMacroID())
6737       RegionOfInterest.setBegin(SM.getExpansionLoc(Loc));
6738   }
6739
6740   if (CXXUnit->getPreprocessor().getPreprocessingRecord()) {
6741     // Search and mark tokens that are macro argument expansions.
6742     MarkMacroArgTokensVisitor Visitor(CXXUnit->getSourceManager(),
6743                                       Tokens, NumTokens);
6744     CursorVisitor MacroArgMarker(TU,
6745                                  MarkMacroArgTokensVisitorDelegate, &Visitor,
6746                                  /*VisitPreprocessorLast=*/true,
6747                                  /*VisitIncludedEntities=*/false,
6748                                  RegionOfInterest);
6749     MacroArgMarker.visitPreprocessedEntitiesInRegion();
6750   }
6751
6752   // Annotate all of the source locations in the region of interest that map to
6753   // a specific cursor.
6754   AnnotateTokensWorker W(Tokens, Cursors, NumTokens, TU, RegionOfInterest);
6755
6756   // FIXME: We use a ridiculous stack size here because the data-recursion
6757   // algorithm uses a large stack frame than the non-data recursive version,
6758   // and AnnotationTokensWorker currently transforms the data-recursion
6759   // algorithm back into a traditional recursion by explicitly calling
6760   // VisitChildren().  We will need to remove this explicit recursive call.
6761   W.AnnotateTokens();
6762
6763   // If we ran into any entities that involve context-sensitive keywords,
6764   // take another pass through the tokens to mark them as such.
6765   if (W.hasContextSensitiveKeywords()) {
6766     for (unsigned I = 0; I != NumTokens; ++I) {
6767       if (clang_getTokenKind(Tokens[I]) != CXToken_Identifier)
6768         continue;
6769
6770       if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) {
6771         IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data);
6772         if (const ObjCPropertyDecl *Property
6773             = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(Cursors[I]))) {
6774           if (Property->getPropertyAttributesAsWritten() != 0 &&
6775               llvm::StringSwitch<bool>(II->getName())
6776               .Case("readonly", true)
6777               .Case("assign", true)
6778               .Case("unsafe_unretained", true)
6779               .Case("readwrite", true)
6780               .Case("retain", true)
6781               .Case("copy", true)
6782               .Case("nonatomic", true)
6783               .Case("atomic", true)
6784               .Case("getter", true)
6785               .Case("setter", true)
6786               .Case("strong", true)
6787               .Case("weak", true)
6788               .Case("class", true)
6789               .Default(false))
6790             Tokens[I].int_data[0] = CXToken_Keyword;
6791         }
6792         continue;
6793       }
6794
6795       if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl ||
6796           Cursors[I].kind == CXCursor_ObjCClassMethodDecl) {
6797         IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data);
6798         if (llvm::StringSwitch<bool>(II->getName())
6799             .Case("in", true)
6800             .Case("out", true)
6801             .Case("inout", true)
6802             .Case("oneway", true)
6803             .Case("bycopy", true)
6804             .Case("byref", true)
6805             .Default(false))
6806           Tokens[I].int_data[0] = CXToken_Keyword;
6807         continue;
6808       }
6809
6810       if (Cursors[I].kind == CXCursor_CXXFinalAttr ||
6811           Cursors[I].kind == CXCursor_CXXOverrideAttr) {
6812         Tokens[I].int_data[0] = CXToken_Keyword;
6813         continue;
6814       }
6815     }
6816   }
6817 }
6818
6819 extern "C" {
6820
6821 void clang_annotateTokens(CXTranslationUnit TU,
6822                           CXToken *Tokens, unsigned NumTokens,
6823                           CXCursor *Cursors) {
6824   if (isNotUsableTU(TU)) {
6825     LOG_BAD_TU(TU);
6826     return;
6827   }
6828   if (NumTokens == 0 || !Tokens || !Cursors) {
6829     LOG_FUNC_SECTION { *Log << "<null input>"; }
6830     return;
6831   }
6832
6833   LOG_FUNC_SECTION {
6834     *Log << TU << ' ';
6835     CXSourceLocation bloc = clang_getTokenLocation(TU, Tokens[0]);
6836     CXSourceLocation eloc = clang_getTokenLocation(TU, Tokens[NumTokens-1]);
6837     *Log << clang_getRange(bloc, eloc);
6838   }
6839
6840   // Any token we don't specifically annotate will have a NULL cursor.
6841   CXCursor C = clang_getNullCursor();
6842   for (unsigned I = 0; I != NumTokens; ++I)
6843     Cursors[I] = C;
6844
6845   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
6846   if (!CXXUnit)
6847     return;
6848
6849   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
6850
6851   auto AnnotateTokensImpl = [=]() {
6852     clang_annotateTokensImpl(TU, CXXUnit, Tokens, NumTokens, Cursors);
6853   };
6854   llvm::CrashRecoveryContext CRC;
6855   if (!RunSafely(CRC, AnnotateTokensImpl, GetSafetyThreadStackSize() * 2)) {
6856     fprintf(stderr, "libclang: crash detected while annotating tokens\n");
6857   }
6858 }
6859
6860 } // end: extern "C"
6861
6862 //===----------------------------------------------------------------------===//
6863 // Operations for querying linkage of a cursor.
6864 //===----------------------------------------------------------------------===//
6865
6866 extern "C" {
6867 CXLinkageKind clang_getCursorLinkage(CXCursor cursor) {
6868   if (!clang_isDeclaration(cursor.kind))
6869     return CXLinkage_Invalid;
6870
6871   const Decl *D = cxcursor::getCursorDecl(cursor);
6872   if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D))
6873     switch (ND->getLinkageInternal()) {
6874       case NoLinkage:
6875       case VisibleNoLinkage: return CXLinkage_NoLinkage;
6876       case InternalLinkage: return CXLinkage_Internal;
6877       case UniqueExternalLinkage: return CXLinkage_UniqueExternal;
6878       case ExternalLinkage: return CXLinkage_External;
6879     };
6880
6881   return CXLinkage_Invalid;
6882 }
6883 } // end: extern "C"
6884
6885 //===----------------------------------------------------------------------===//
6886 // Operations for querying visibility of a cursor.
6887 //===----------------------------------------------------------------------===//
6888
6889 extern "C" {
6890 CXVisibilityKind clang_getCursorVisibility(CXCursor cursor) {
6891   if (!clang_isDeclaration(cursor.kind))
6892     return CXVisibility_Invalid;
6893
6894   const Decl *D = cxcursor::getCursorDecl(cursor);
6895   if (const NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D))
6896     switch (ND->getVisibility()) {
6897       case HiddenVisibility: return CXVisibility_Hidden;
6898       case ProtectedVisibility: return CXVisibility_Protected;
6899       case DefaultVisibility: return CXVisibility_Default;
6900     };
6901
6902   return CXVisibility_Invalid;
6903 }
6904 } // end: extern "C"
6905
6906 //===----------------------------------------------------------------------===//
6907 // Operations for querying language of a cursor.
6908 //===----------------------------------------------------------------------===//
6909
6910 static CXLanguageKind getDeclLanguage(const Decl *D) {
6911   if (!D)
6912     return CXLanguage_C;
6913
6914   switch (D->getKind()) {
6915     default:
6916       break;
6917     case Decl::ImplicitParam:
6918     case Decl::ObjCAtDefsField:
6919     case Decl::ObjCCategory:
6920     case Decl::ObjCCategoryImpl:
6921     case Decl::ObjCCompatibleAlias:
6922     case Decl::ObjCImplementation:
6923     case Decl::ObjCInterface:
6924     case Decl::ObjCIvar:
6925     case Decl::ObjCMethod:
6926     case Decl::ObjCProperty:
6927     case Decl::ObjCPropertyImpl:
6928     case Decl::ObjCProtocol:
6929     case Decl::ObjCTypeParam:
6930       return CXLanguage_ObjC;
6931     case Decl::CXXConstructor:
6932     case Decl::CXXConversion:
6933     case Decl::CXXDestructor:
6934     case Decl::CXXMethod:
6935     case Decl::CXXRecord:
6936     case Decl::ClassTemplate:
6937     case Decl::ClassTemplatePartialSpecialization:
6938     case Decl::ClassTemplateSpecialization:
6939     case Decl::Friend:
6940     case Decl::FriendTemplate:
6941     case Decl::FunctionTemplate:
6942     case Decl::LinkageSpec:
6943     case Decl::Namespace:
6944     case Decl::NamespaceAlias:
6945     case Decl::NonTypeTemplateParm:
6946     case Decl::StaticAssert:
6947     case Decl::TemplateTemplateParm:
6948     case Decl::TemplateTypeParm:
6949     case Decl::UnresolvedUsingTypename:
6950     case Decl::UnresolvedUsingValue:
6951     case Decl::Using:
6952     case Decl::UsingDirective:
6953     case Decl::UsingShadow:
6954       return CXLanguage_CPlusPlus;
6955   }
6956
6957   return CXLanguage_C;
6958 }
6959
6960 extern "C" {
6961
6962 static CXAvailabilityKind getCursorAvailabilityForDecl(const Decl *D) {
6963   if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted())
6964     return CXAvailability_NotAvailable;
6965
6966   switch (D->getAvailability()) {
6967   case AR_Available:
6968   case AR_NotYetIntroduced:
6969     if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D))
6970       return getCursorAvailabilityForDecl(
6971           cast<Decl>(EnumConst->getDeclContext()));
6972     return CXAvailability_Available;
6973
6974   case AR_Deprecated:
6975     return CXAvailability_Deprecated;
6976
6977   case AR_Unavailable:
6978     return CXAvailability_NotAvailable;
6979   }
6980
6981   llvm_unreachable("Unknown availability kind!");
6982 }
6983
6984 enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) {
6985   if (clang_isDeclaration(cursor.kind))
6986     if (const Decl *D = cxcursor::getCursorDecl(cursor))
6987       return getCursorAvailabilityForDecl(D);
6988
6989   return CXAvailability_Available;
6990 }
6991
6992 static CXVersion convertVersion(VersionTuple In) {
6993   CXVersion Out = { -1, -1, -1 };
6994   if (In.empty())
6995     return Out;
6996
6997   Out.Major = In.getMajor();
6998
6999   Optional<unsigned> Minor = In.getMinor();
7000   if (Minor.hasValue())
7001     Out.Minor = *Minor;
7002   else
7003     return Out;
7004
7005   Optional<unsigned> Subminor = In.getSubminor();
7006   if (Subminor.hasValue())
7007     Out.Subminor = *Subminor;
7008
7009   return Out;
7010 }
7011
7012 static int getCursorPlatformAvailabilityForDecl(const Decl *D,
7013                                                 int *always_deprecated,
7014                                                 CXString *deprecated_message,
7015                                                 int *always_unavailable,
7016                                                 CXString *unavailable_message,
7017                                            CXPlatformAvailability *availability,
7018                                                 int availability_size) {
7019   bool HadAvailAttr = false;
7020   int N = 0;
7021   for (auto A : D->attrs()) {
7022     if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(A)) {
7023       HadAvailAttr = true;
7024       if (always_deprecated)
7025         *always_deprecated = 1;
7026       if (deprecated_message) {
7027         clang_disposeString(*deprecated_message);
7028         *deprecated_message = cxstring::createDup(Deprecated->getMessage());
7029       }
7030       continue;
7031     }
7032
7033     if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(A)) {
7034       HadAvailAttr = true;
7035       if (always_unavailable)
7036         *always_unavailable = 1;
7037       if (unavailable_message) {
7038         clang_disposeString(*unavailable_message);
7039         *unavailable_message = cxstring::createDup(Unavailable->getMessage());
7040       }
7041       continue;
7042     }
7043
7044     if (AvailabilityAttr *Avail = dyn_cast<AvailabilityAttr>(A)) {
7045       HadAvailAttr = true;
7046       if (N < availability_size) {
7047         availability[N].Platform
7048           = cxstring::createDup(Avail->getPlatform()->getName());
7049         availability[N].Introduced = convertVersion(Avail->getIntroduced());
7050         availability[N].Deprecated = convertVersion(Avail->getDeprecated());
7051         availability[N].Obsoleted = convertVersion(Avail->getObsoleted());
7052         availability[N].Unavailable = Avail->getUnavailable();
7053         availability[N].Message = cxstring::createDup(Avail->getMessage());
7054       }
7055       ++N;
7056     }
7057   }
7058
7059   if (!HadAvailAttr)
7060     if (const EnumConstantDecl *EnumConst = dyn_cast<EnumConstantDecl>(D))
7061       return getCursorPlatformAvailabilityForDecl(
7062                                         cast<Decl>(EnumConst->getDeclContext()),
7063                                                   always_deprecated,
7064                                                   deprecated_message,
7065                                                   always_unavailable,
7066                                                   unavailable_message,
7067                                                   availability,
7068                                                   availability_size);
7069
7070   return N;
7071 }
7072
7073 int clang_getCursorPlatformAvailability(CXCursor cursor,
7074                                         int *always_deprecated,
7075                                         CXString *deprecated_message,
7076                                         int *always_unavailable,
7077                                         CXString *unavailable_message,
7078                                         CXPlatformAvailability *availability,
7079                                         int availability_size) {
7080   if (always_deprecated)
7081     *always_deprecated = 0;
7082   if (deprecated_message)
7083     *deprecated_message = cxstring::createEmpty();
7084   if (always_unavailable)
7085     *always_unavailable = 0;
7086   if (unavailable_message)
7087     *unavailable_message = cxstring::createEmpty();
7088
7089   if (!clang_isDeclaration(cursor.kind))
7090     return 0;
7091
7092   const Decl *D = cxcursor::getCursorDecl(cursor);
7093   if (!D)
7094     return 0;
7095
7096   return getCursorPlatformAvailabilityForDecl(D, always_deprecated,
7097                                               deprecated_message,
7098                                               always_unavailable,
7099                                               unavailable_message,
7100                                               availability,
7101                                               availability_size);
7102 }
7103
7104 void clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability) {
7105   clang_disposeString(availability->Platform);
7106   clang_disposeString(availability->Message);
7107 }
7108
7109 CXLanguageKind clang_getCursorLanguage(CXCursor cursor) {
7110   if (clang_isDeclaration(cursor.kind))
7111     return getDeclLanguage(cxcursor::getCursorDecl(cursor));
7112
7113   return CXLanguage_Invalid;
7114 }
7115
7116  /// \brief If the given cursor is the "templated" declaration
7117  /// descibing a class or function template, return the class or
7118  /// function template.
7119 static const Decl *maybeGetTemplateCursor(const Decl *D) {
7120   if (!D)
7121     return nullptr;
7122
7123   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
7124     if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate())
7125       return FunTmpl;
7126
7127   if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
7128     if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate())
7129       return ClassTmpl;
7130
7131   return D;
7132 }
7133
7134
7135 enum CX_StorageClass clang_Cursor_getStorageClass(CXCursor C) {
7136   StorageClass sc = SC_None;
7137   const Decl *D = getCursorDecl(C);
7138   if (D) {
7139     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
7140       sc = FD->getStorageClass();
7141     } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
7142       sc = VD->getStorageClass();
7143     } else {
7144       return CX_SC_Invalid;
7145     }
7146   } else {
7147     return CX_SC_Invalid;
7148   }
7149   switch (sc) {
7150   case SC_None:
7151     return CX_SC_None;
7152   case SC_Extern:
7153     return CX_SC_Extern;
7154   case SC_Static:
7155     return CX_SC_Static;
7156   case SC_PrivateExtern:
7157     return CX_SC_PrivateExtern;
7158   case SC_Auto:
7159     return CX_SC_Auto;
7160   case SC_Register:
7161     return CX_SC_Register;
7162   }
7163   llvm_unreachable("Unhandled storage class!");
7164 }
7165
7166 CXCursor clang_getCursorSemanticParent(CXCursor cursor) {
7167   if (clang_isDeclaration(cursor.kind)) {
7168     if (const Decl *D = getCursorDecl(cursor)) {
7169       const DeclContext *DC = D->getDeclContext();
7170       if (!DC)
7171         return clang_getNullCursor();
7172
7173       return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)),
7174                           getCursorTU(cursor));
7175     }
7176   }
7177
7178   if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) {
7179     if (const Decl *D = getCursorDecl(cursor))
7180       return MakeCXCursor(D, getCursorTU(cursor));
7181   }
7182
7183   return clang_getNullCursor();
7184 }
7185
7186 CXCursor clang_getCursorLexicalParent(CXCursor cursor) {
7187   if (clang_isDeclaration(cursor.kind)) {
7188     if (const Decl *D = getCursorDecl(cursor)) {
7189       const DeclContext *DC = D->getLexicalDeclContext();
7190       if (!DC)
7191         return clang_getNullCursor();
7192
7193       return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)),
7194                           getCursorTU(cursor));
7195     }
7196   }
7197
7198   // FIXME: Note that we can't easily compute the lexical context of a
7199   // statement or expression, so we return nothing.
7200   return clang_getNullCursor();
7201 }
7202
7203 CXFile clang_getIncludedFile(CXCursor cursor) {
7204   if (cursor.kind != CXCursor_InclusionDirective)
7205     return nullptr;
7206
7207   const InclusionDirective *ID = getCursorInclusionDirective(cursor);
7208   return const_cast<FileEntry *>(ID->getFile());
7209 }
7210
7211 unsigned clang_Cursor_getObjCPropertyAttributes(CXCursor C, unsigned reserved) {
7212   if (C.kind != CXCursor_ObjCPropertyDecl)
7213     return CXObjCPropertyAttr_noattr;
7214
7215   unsigned Result = CXObjCPropertyAttr_noattr;
7216   const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(getCursorDecl(C));
7217   ObjCPropertyDecl::PropertyAttributeKind Attr =
7218       PD->getPropertyAttributesAsWritten();
7219
7220 #define SET_CXOBJCPROP_ATTR(A) \
7221   if (Attr & ObjCPropertyDecl::OBJC_PR_##A) \
7222     Result |= CXObjCPropertyAttr_##A
7223   SET_CXOBJCPROP_ATTR(readonly);
7224   SET_CXOBJCPROP_ATTR(getter);
7225   SET_CXOBJCPROP_ATTR(assign);
7226   SET_CXOBJCPROP_ATTR(readwrite);
7227   SET_CXOBJCPROP_ATTR(retain);
7228   SET_CXOBJCPROP_ATTR(copy);
7229   SET_CXOBJCPROP_ATTR(nonatomic);
7230   SET_CXOBJCPROP_ATTR(setter);
7231   SET_CXOBJCPROP_ATTR(atomic);
7232   SET_CXOBJCPROP_ATTR(weak);
7233   SET_CXOBJCPROP_ATTR(strong);
7234   SET_CXOBJCPROP_ATTR(unsafe_unretained);
7235   SET_CXOBJCPROP_ATTR(class);
7236 #undef SET_CXOBJCPROP_ATTR
7237
7238   return Result;
7239 }
7240
7241 unsigned clang_Cursor_getObjCDeclQualifiers(CXCursor C) {
7242   if (!clang_isDeclaration(C.kind))
7243     return CXObjCDeclQualifier_None;
7244
7245   Decl::ObjCDeclQualifier QT = Decl::OBJC_TQ_None;
7246   const Decl *D = getCursorDecl(C);
7247   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
7248     QT = MD->getObjCDeclQualifier();
7249   else if (const ParmVarDecl *PD = dyn_cast<ParmVarDecl>(D))
7250     QT = PD->getObjCDeclQualifier();
7251   if (QT == Decl::OBJC_TQ_None)
7252     return CXObjCDeclQualifier_None;
7253
7254   unsigned Result = CXObjCDeclQualifier_None;
7255   if (QT & Decl::OBJC_TQ_In) Result |= CXObjCDeclQualifier_In;
7256   if (QT & Decl::OBJC_TQ_Inout) Result |= CXObjCDeclQualifier_Inout;
7257   if (QT & Decl::OBJC_TQ_Out) Result |= CXObjCDeclQualifier_Out;
7258   if (QT & Decl::OBJC_TQ_Bycopy) Result |= CXObjCDeclQualifier_Bycopy;
7259   if (QT & Decl::OBJC_TQ_Byref) Result |= CXObjCDeclQualifier_Byref;
7260   if (QT & Decl::OBJC_TQ_Oneway) Result |= CXObjCDeclQualifier_Oneway;
7261
7262   return Result;
7263 }
7264
7265 unsigned clang_Cursor_isObjCOptional(CXCursor C) {
7266   if (!clang_isDeclaration(C.kind))
7267     return 0;
7268
7269   const Decl *D = getCursorDecl(C);
7270   if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
7271     return PD->getPropertyImplementation() == ObjCPropertyDecl::Optional;
7272   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
7273     return MD->getImplementationControl() == ObjCMethodDecl::Optional;
7274
7275   return 0;
7276 }
7277
7278 unsigned clang_Cursor_isVariadic(CXCursor C) {
7279   if (!clang_isDeclaration(C.kind))
7280     return 0;
7281
7282   const Decl *D = getCursorDecl(C);
7283   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
7284     return FD->isVariadic();
7285   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
7286     return MD->isVariadic();
7287
7288   return 0;
7289 }
7290
7291 CXSourceRange clang_Cursor_getCommentRange(CXCursor C) {
7292   if (!clang_isDeclaration(C.kind))
7293     return clang_getNullRange();
7294
7295   const Decl *D = getCursorDecl(C);
7296   ASTContext &Context = getCursorContext(C);
7297   const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
7298   if (!RC)
7299     return clang_getNullRange();
7300
7301   return cxloc::translateSourceRange(Context, RC->getSourceRange());
7302 }
7303
7304 CXString clang_Cursor_getRawCommentText(CXCursor C) {
7305   if (!clang_isDeclaration(C.kind))
7306     return cxstring::createNull();
7307
7308   const Decl *D = getCursorDecl(C);
7309   ASTContext &Context = getCursorContext(C);
7310   const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
7311   StringRef RawText = RC ? RC->getRawText(Context.getSourceManager()) :
7312                            StringRef();
7313
7314   // Don't duplicate the string because RawText points directly into source
7315   // code.
7316   return cxstring::createRef(RawText);
7317 }
7318
7319 CXString clang_Cursor_getBriefCommentText(CXCursor C) {
7320   if (!clang_isDeclaration(C.kind))
7321     return cxstring::createNull();
7322
7323   const Decl *D = getCursorDecl(C);
7324   const ASTContext &Context = getCursorContext(C);
7325   const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
7326
7327   if (RC) {
7328     StringRef BriefText = RC->getBriefText(Context);
7329
7330     // Don't duplicate the string because RawComment ensures that this memory
7331     // will not go away.
7332     return cxstring::createRef(BriefText);
7333   }
7334
7335   return cxstring::createNull();
7336 }
7337
7338 CXModule clang_Cursor_getModule(CXCursor C) {
7339   if (C.kind == CXCursor_ModuleImportDecl) {
7340     if (const ImportDecl *ImportD =
7341             dyn_cast_or_null<ImportDecl>(getCursorDecl(C)))
7342       return ImportD->getImportedModule();
7343   }
7344
7345   return nullptr;
7346 }
7347
7348 CXModule clang_getModuleForFile(CXTranslationUnit TU, CXFile File) {
7349   if (isNotUsableTU(TU)) {
7350     LOG_BAD_TU(TU);
7351     return nullptr;
7352   }
7353   if (!File)
7354     return nullptr;
7355   FileEntry *FE = static_cast<FileEntry *>(File);
7356
7357   ASTUnit &Unit = *cxtu::getASTUnit(TU);
7358   HeaderSearch &HS = Unit.getPreprocessor().getHeaderSearchInfo();
7359   ModuleMap::KnownHeader Header = HS.findModuleForHeader(FE);
7360
7361   return Header.getModule();
7362 }
7363
7364 CXFile clang_Module_getASTFile(CXModule CXMod) {
7365   if (!CXMod)
7366     return nullptr;
7367   Module *Mod = static_cast<Module*>(CXMod);
7368   return const_cast<FileEntry *>(Mod->getASTFile());
7369 }
7370
7371 CXModule clang_Module_getParent(CXModule CXMod) {
7372   if (!CXMod)
7373     return nullptr;
7374   Module *Mod = static_cast<Module*>(CXMod);
7375   return Mod->Parent;
7376 }
7377
7378 CXString clang_Module_getName(CXModule CXMod) {
7379   if (!CXMod)
7380     return cxstring::createEmpty();
7381   Module *Mod = static_cast<Module*>(CXMod);
7382   return cxstring::createDup(Mod->Name);
7383 }
7384
7385 CXString clang_Module_getFullName(CXModule CXMod) {
7386   if (!CXMod)
7387     return cxstring::createEmpty();
7388   Module *Mod = static_cast<Module*>(CXMod);
7389   return cxstring::createDup(Mod->getFullModuleName());
7390 }
7391
7392 int clang_Module_isSystem(CXModule CXMod) {
7393   if (!CXMod)
7394     return 0;
7395   Module *Mod = static_cast<Module*>(CXMod);
7396   return Mod->IsSystem;
7397 }
7398
7399 unsigned clang_Module_getNumTopLevelHeaders(CXTranslationUnit TU,
7400                                             CXModule CXMod) {
7401   if (isNotUsableTU(TU)) {
7402     LOG_BAD_TU(TU);
7403     return 0;
7404   }
7405   if (!CXMod)
7406     return 0;
7407   Module *Mod = static_cast<Module*>(CXMod);
7408   FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();
7409   ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
7410   return TopHeaders.size();
7411 }
7412
7413 CXFile clang_Module_getTopLevelHeader(CXTranslationUnit TU,
7414                                       CXModule CXMod, unsigned Index) {
7415   if (isNotUsableTU(TU)) {
7416     LOG_BAD_TU(TU);
7417     return nullptr;
7418   }
7419   if (!CXMod)
7420     return nullptr;
7421   Module *Mod = static_cast<Module*>(CXMod);
7422   FileManager &FileMgr = cxtu::getASTUnit(TU)->getFileManager();
7423
7424   ArrayRef<const FileEntry *> TopHeaders = Mod->getTopHeaders(FileMgr);
7425   if (Index < TopHeaders.size())
7426     return const_cast<FileEntry *>(TopHeaders[Index]);
7427
7428   return nullptr;
7429 }
7430
7431 } // end: extern "C"
7432
7433 //===----------------------------------------------------------------------===//
7434 // C++ AST instrospection.
7435 //===----------------------------------------------------------------------===//
7436
7437 extern "C" {
7438
7439 unsigned clang_CXXConstructor_isDefaultConstructor(CXCursor C) {
7440   if (!clang_isDeclaration(C.kind))
7441     return 0;
7442
7443   const Decl *D = cxcursor::getCursorDecl(C);
7444   const CXXConstructorDecl *Constructor =
7445       D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
7446   return (Constructor && Constructor->isDefaultConstructor()) ? 1 : 0;
7447 }
7448
7449 unsigned clang_CXXConstructor_isCopyConstructor(CXCursor C) {
7450   if (!clang_isDeclaration(C.kind))
7451     return 0;
7452
7453   const Decl *D = cxcursor::getCursorDecl(C);
7454   const CXXConstructorDecl *Constructor =
7455       D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
7456   return (Constructor && Constructor->isCopyConstructor()) ? 1 : 0;
7457 }
7458
7459 unsigned clang_CXXConstructor_isMoveConstructor(CXCursor C) {
7460   if (!clang_isDeclaration(C.kind))
7461     return 0;
7462
7463   const Decl *D = cxcursor::getCursorDecl(C);
7464   const CXXConstructorDecl *Constructor =
7465       D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
7466   return (Constructor && Constructor->isMoveConstructor()) ? 1 : 0;
7467 }
7468
7469 unsigned clang_CXXConstructor_isConvertingConstructor(CXCursor C) {
7470   if (!clang_isDeclaration(C.kind))
7471     return 0;
7472
7473   const Decl *D = cxcursor::getCursorDecl(C);
7474   const CXXConstructorDecl *Constructor =
7475       D ? dyn_cast_or_null<CXXConstructorDecl>(D->getAsFunction()) : nullptr;
7476   // Passing 'false' excludes constructors marked 'explicit'.
7477   return (Constructor && Constructor->isConvertingConstructor(false)) ? 1 : 0;
7478 }
7479
7480 unsigned clang_CXXField_isMutable(CXCursor C) {
7481   if (!clang_isDeclaration(C.kind))
7482     return 0;
7483
7484   if (const auto D = cxcursor::getCursorDecl(C))
7485     if (const auto FD = dyn_cast_or_null<FieldDecl>(D))
7486       return FD->isMutable() ? 1 : 0;
7487   return 0;
7488 }
7489
7490 unsigned clang_CXXMethod_isPureVirtual(CXCursor C) {
7491   if (!clang_isDeclaration(C.kind))
7492     return 0;
7493
7494   const Decl *D = cxcursor::getCursorDecl(C);
7495   const CXXMethodDecl *Method =
7496       D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
7497   return (Method && Method->isVirtual() && Method->isPure()) ? 1 : 0;
7498 }
7499
7500 unsigned clang_CXXMethod_isConst(CXCursor C) {
7501   if (!clang_isDeclaration(C.kind))
7502     return 0;
7503
7504   const Decl *D = cxcursor::getCursorDecl(C);
7505   const CXXMethodDecl *Method =
7506       D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
7507   return (Method && (Method->getTypeQualifiers() & Qualifiers::Const)) ? 1 : 0;
7508 }
7509
7510 unsigned clang_CXXMethod_isDefaulted(CXCursor C) {
7511   if (!clang_isDeclaration(C.kind))
7512     return 0;
7513
7514   const Decl *D = cxcursor::getCursorDecl(C);
7515   const CXXMethodDecl *Method =
7516       D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
7517   return (Method && Method->isDefaulted()) ? 1 : 0;
7518 }
7519
7520 unsigned clang_CXXMethod_isStatic(CXCursor C) {
7521   if (!clang_isDeclaration(C.kind))
7522     return 0;
7523
7524   const Decl *D = cxcursor::getCursorDecl(C);
7525   const CXXMethodDecl *Method =
7526       D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
7527   return (Method && Method->isStatic()) ? 1 : 0;
7528 }
7529
7530 unsigned clang_CXXMethod_isVirtual(CXCursor C) {
7531   if (!clang_isDeclaration(C.kind))
7532     return 0;
7533
7534   const Decl *D = cxcursor::getCursorDecl(C);
7535   const CXXMethodDecl *Method =
7536       D ? dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()) : nullptr;
7537   return (Method && Method->isVirtual()) ? 1 : 0;
7538 }
7539 } // end: extern "C"
7540
7541 //===----------------------------------------------------------------------===//
7542 // Attribute introspection.
7543 //===----------------------------------------------------------------------===//
7544
7545 extern "C" {
7546 CXType clang_getIBOutletCollectionType(CXCursor C) {
7547   if (C.kind != CXCursor_IBOutletCollectionAttr)
7548     return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C));
7549
7550   const IBOutletCollectionAttr *A =
7551     cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C));
7552
7553   return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorTU(C));
7554 }
7555 } // end: extern "C"
7556
7557 //===----------------------------------------------------------------------===//
7558 // Inspecting memory usage.
7559 //===----------------------------------------------------------------------===//
7560
7561 typedef std::vector<CXTUResourceUsageEntry> MemUsageEntries;
7562
7563 static inline void createCXTUResourceUsageEntry(MemUsageEntries &entries,
7564                                               enum CXTUResourceUsageKind k,
7565                                               unsigned long amount) {
7566   CXTUResourceUsageEntry entry = { k, amount };
7567   entries.push_back(entry);
7568 }
7569
7570 extern "C" {
7571
7572 const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) {
7573   const char *str = "";
7574   switch (kind) {
7575     case CXTUResourceUsage_AST:
7576       str = "ASTContext: expressions, declarations, and types";
7577       break;
7578     case CXTUResourceUsage_Identifiers:
7579       str = "ASTContext: identifiers";
7580       break;
7581     case CXTUResourceUsage_Selectors:
7582       str = "ASTContext: selectors";
7583       break;
7584     case CXTUResourceUsage_GlobalCompletionResults:
7585       str = "Code completion: cached global results";
7586       break;
7587     case CXTUResourceUsage_SourceManagerContentCache:
7588       str = "SourceManager: content cache allocator";
7589       break;
7590     case CXTUResourceUsage_AST_SideTables:
7591       str = "ASTContext: side tables";
7592       break;
7593     case CXTUResourceUsage_SourceManager_Membuffer_Malloc:
7594       str = "SourceManager: malloc'ed memory buffers";
7595       break;
7596     case CXTUResourceUsage_SourceManager_Membuffer_MMap:
7597       str = "SourceManager: mmap'ed memory buffers";
7598       break;
7599     case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc:
7600       str = "ExternalASTSource: malloc'ed memory buffers";
7601       break;
7602     case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap:
7603       str = "ExternalASTSource: mmap'ed memory buffers";
7604       break;
7605     case CXTUResourceUsage_Preprocessor:
7606       str = "Preprocessor: malloc'ed memory";
7607       break;
7608     case CXTUResourceUsage_PreprocessingRecord:
7609       str = "Preprocessor: PreprocessingRecord";
7610       break;
7611     case CXTUResourceUsage_SourceManager_DataStructures:
7612       str = "SourceManager: data structures and tables";
7613       break;
7614     case CXTUResourceUsage_Preprocessor_HeaderSearch:
7615       str = "Preprocessor: header search tables";
7616       break;
7617   }
7618   return str;
7619 }
7620
7621 CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU) {
7622   if (isNotUsableTU(TU)) {
7623     LOG_BAD_TU(TU);
7624     CXTUResourceUsage usage = { (void*) nullptr, 0, nullptr };
7625     return usage;
7626   }
7627
7628   ASTUnit *astUnit = cxtu::getASTUnit(TU);
7629   std::unique_ptr<MemUsageEntries> entries(new MemUsageEntries());
7630   ASTContext &astContext = astUnit->getASTContext();
7631
7632   // How much memory is used by AST nodes and types?
7633   createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST,
7634     (unsigned long) astContext.getASTAllocatedMemory());
7635
7636   // How much memory is used by identifiers?
7637   createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Identifiers,
7638     (unsigned long) astContext.Idents.getAllocator().getTotalMemory());
7639
7640   // How much memory is used for selectors?
7641   createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Selectors,
7642     (unsigned long) astContext.Selectors.getTotalMemory());
7643
7644   // How much memory is used by ASTContext's side tables?
7645   createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST_SideTables,
7646     (unsigned long) astContext.getSideTableAllocatedMemory());
7647
7648   // How much memory is used for caching global code completion results?
7649   unsigned long completionBytes = 0;
7650   if (GlobalCodeCompletionAllocator *completionAllocator =
7651       astUnit->getCachedCompletionAllocator().get()) {
7652     completionBytes = completionAllocator->getTotalMemory();
7653   }
7654   createCXTUResourceUsageEntry(*entries,
7655                                CXTUResourceUsage_GlobalCompletionResults,
7656                                completionBytes);
7657
7658   // How much memory is being used by SourceManager's content cache?
7659   createCXTUResourceUsageEntry(*entries,
7660           CXTUResourceUsage_SourceManagerContentCache,
7661           (unsigned long) astContext.getSourceManager().getContentCacheSize());
7662
7663   // How much memory is being used by the MemoryBuffer's in SourceManager?
7664   const SourceManager::MemoryBufferSizes &srcBufs =
7665     astUnit->getSourceManager().getMemoryBufferSizes();
7666
7667   createCXTUResourceUsageEntry(*entries,
7668                                CXTUResourceUsage_SourceManager_Membuffer_Malloc,
7669                                (unsigned long) srcBufs.malloc_bytes);
7670   createCXTUResourceUsageEntry(*entries,
7671                                CXTUResourceUsage_SourceManager_Membuffer_MMap,
7672                                (unsigned long) srcBufs.mmap_bytes);
7673   createCXTUResourceUsageEntry(*entries,
7674                                CXTUResourceUsage_SourceManager_DataStructures,
7675                                (unsigned long) astContext.getSourceManager()
7676                                 .getDataStructureSizes());
7677
7678   // How much memory is being used by the ExternalASTSource?
7679   if (ExternalASTSource *esrc = astContext.getExternalSource()) {
7680     const ExternalASTSource::MemoryBufferSizes &sizes =
7681       esrc->getMemoryBufferSizes();
7682
7683     createCXTUResourceUsageEntry(*entries,
7684       CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc,
7685                                  (unsigned long) sizes.malloc_bytes);
7686     createCXTUResourceUsageEntry(*entries,
7687       CXTUResourceUsage_ExternalASTSource_Membuffer_MMap,
7688                                  (unsigned long) sizes.mmap_bytes);
7689   }
7690
7691   // How much memory is being used by the Preprocessor?
7692   Preprocessor &pp = astUnit->getPreprocessor();
7693   createCXTUResourceUsageEntry(*entries,
7694                                CXTUResourceUsage_Preprocessor,
7695                                pp.getTotalMemory());
7696
7697   if (PreprocessingRecord *pRec = pp.getPreprocessingRecord()) {
7698     createCXTUResourceUsageEntry(*entries,
7699                                  CXTUResourceUsage_PreprocessingRecord,
7700                                  pRec->getTotalMemory());
7701   }
7702
7703   createCXTUResourceUsageEntry(*entries,
7704                                CXTUResourceUsage_Preprocessor_HeaderSearch,
7705                                pp.getHeaderSearchInfo().getTotalMemory());
7706
7707   CXTUResourceUsage usage = { (void*) entries.get(),
7708                             (unsigned) entries->size(),
7709                             !entries->empty() ? &(*entries)[0] : nullptr };
7710   entries.release();
7711   return usage;
7712 }
7713
7714 void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage) {
7715   if (usage.data)
7716     delete (MemUsageEntries*) usage.data;
7717 }
7718
7719 CXSourceRangeList *clang_getSkippedRanges(CXTranslationUnit TU, CXFile file) {
7720   CXSourceRangeList *skipped = new CXSourceRangeList;
7721   skipped->count = 0;
7722   skipped->ranges = nullptr;
7723
7724   if (isNotUsableTU(TU)) {
7725     LOG_BAD_TU(TU);
7726     return skipped;
7727   }
7728
7729   if (!file)
7730     return skipped;
7731
7732   ASTUnit *astUnit = cxtu::getASTUnit(TU);
7733   PreprocessingRecord *ppRec = astUnit->getPreprocessor().getPreprocessingRecord();
7734   if (!ppRec)
7735     return skipped;
7736
7737   ASTContext &Ctx = astUnit->getASTContext();
7738   SourceManager &sm = Ctx.getSourceManager();
7739   FileEntry *fileEntry = static_cast<FileEntry *>(file);
7740   FileID wantedFileID = sm.translateFile(fileEntry);
7741
7742   const std::vector<SourceRange> &SkippedRanges = ppRec->getSkippedRanges();
7743   std::vector<SourceRange> wantedRanges;
7744   for (std::vector<SourceRange>::const_iterator i = SkippedRanges.begin(), ei = SkippedRanges.end();
7745        i != ei; ++i) {
7746     if (sm.getFileID(i->getBegin()) == wantedFileID || sm.getFileID(i->getEnd()) == wantedFileID)
7747       wantedRanges.push_back(*i);
7748   }
7749
7750   skipped->count = wantedRanges.size();
7751   skipped->ranges = new CXSourceRange[skipped->count];
7752   for (unsigned i = 0, ei = skipped->count; i != ei; ++i)
7753     skipped->ranges[i] = cxloc::translateSourceRange(Ctx, wantedRanges[i]);
7754
7755   return skipped;
7756 }
7757
7758 void clang_disposeSourceRangeList(CXSourceRangeList *ranges) {
7759   if (ranges) {
7760     delete[] ranges->ranges;
7761     delete ranges;
7762   }
7763 }
7764
7765 } // end extern "C"
7766
7767 void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) {
7768   CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU);
7769   for (unsigned I = 0; I != Usage.numEntries; ++I)
7770     fprintf(stderr, "  %s: %lu\n",
7771             clang_getTUResourceUsageName(Usage.entries[I].kind),
7772             Usage.entries[I].amount);
7773
7774   clang_disposeCXTUResourceUsage(Usage);
7775 }
7776
7777 //===----------------------------------------------------------------------===//
7778 // Misc. utility functions.
7779 //===----------------------------------------------------------------------===//
7780
7781 /// Default to using an 8 MB stack size on "safety" threads.
7782 static unsigned SafetyStackThreadSize = 8 << 20;
7783
7784 namespace clang {
7785
7786 bool RunSafely(llvm::CrashRecoveryContext &CRC, llvm::function_ref<void()> Fn,
7787                unsigned Size) {
7788   if (!Size)
7789     Size = GetSafetyThreadStackSize();
7790   if (Size)
7791     return CRC.RunSafelyOnThread(Fn, Size);
7792   return CRC.RunSafely(Fn);
7793 }
7794
7795 unsigned GetSafetyThreadStackSize() {
7796   return SafetyStackThreadSize;
7797 }
7798
7799 void SetSafetyThreadStackSize(unsigned Value) {
7800   SafetyStackThreadSize = Value;
7801 }
7802
7803 }
7804
7805 void clang::setThreadBackgroundPriority() {
7806   if (getenv("LIBCLANG_BGPRIO_DISABLE"))
7807     return;
7808
7809 #ifdef USE_DARWIN_THREADS
7810   setpriority(PRIO_DARWIN_THREAD, 0, PRIO_DARWIN_BG);
7811 #endif
7812 }
7813
7814 void cxindex::printDiagsToStderr(ASTUnit *Unit) {
7815   if (!Unit)
7816     return;
7817
7818   for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(),
7819                                   DEnd = Unit->stored_diag_end();
7820        D != DEnd; ++D) {
7821     CXStoredDiagnostic Diag(*D, Unit->getLangOpts());
7822     CXString Msg = clang_formatDiagnostic(&Diag,
7823                                 clang_defaultDiagnosticDisplayOptions());
7824     fprintf(stderr, "%s\n", clang_getCString(Msg));
7825     clang_disposeString(Msg);
7826   }
7827 #ifdef LLVM_ON_WIN32
7828   // On Windows, force a flush, since there may be multiple copies of
7829   // stderr and stdout in the file system, all with different buffers
7830   // but writing to the same device.
7831   fflush(stderr);
7832 #endif
7833 }
7834
7835 MacroInfo *cxindex::getMacroInfo(const IdentifierInfo &II,
7836                                  SourceLocation MacroDefLoc,
7837                                  CXTranslationUnit TU){
7838   if (MacroDefLoc.isInvalid() || !TU)
7839     return nullptr;
7840   if (!II.hadMacroDefinition())
7841     return nullptr;
7842
7843   ASTUnit *Unit = cxtu::getASTUnit(TU);
7844   Preprocessor &PP = Unit->getPreprocessor();
7845   MacroDirective *MD = PP.getLocalMacroDirectiveHistory(&II);
7846   if (MD) {
7847     for (MacroDirective::DefInfo
7848            Def = MD->getDefinition(); Def; Def = Def.getPreviousDefinition()) {
7849       if (MacroDefLoc == Def.getMacroInfo()->getDefinitionLoc())
7850         return Def.getMacroInfo();
7851     }
7852   }
7853
7854   return nullptr;
7855 }
7856
7857 const MacroInfo *cxindex::getMacroInfo(const MacroDefinitionRecord *MacroDef,
7858                                        CXTranslationUnit TU) {
7859   if (!MacroDef || !TU)
7860     return nullptr;
7861   const IdentifierInfo *II = MacroDef->getName();
7862   if (!II)
7863     return nullptr;
7864
7865   return getMacroInfo(*II, MacroDef->getLocation(), TU);
7866 }
7867
7868 MacroDefinitionRecord *
7869 cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, const Token &Tok,
7870                                         CXTranslationUnit TU) {
7871   if (!MI || !TU)
7872     return nullptr;
7873   if (Tok.isNot(tok::raw_identifier))
7874     return nullptr;
7875
7876   if (MI->getNumTokens() == 0)
7877     return nullptr;
7878   SourceRange DefRange(MI->getReplacementToken(0).getLocation(),
7879                        MI->getDefinitionEndLoc());
7880   ASTUnit *Unit = cxtu::getASTUnit(TU);
7881
7882   // Check that the token is inside the definition and not its argument list.
7883   SourceManager &SM = Unit->getSourceManager();
7884   if (SM.isBeforeInTranslationUnit(Tok.getLocation(), DefRange.getBegin()))
7885     return nullptr;
7886   if (SM.isBeforeInTranslationUnit(DefRange.getEnd(), Tok.getLocation()))
7887     return nullptr;
7888
7889   Preprocessor &PP = Unit->getPreprocessor();
7890   PreprocessingRecord *PPRec = PP.getPreprocessingRecord();
7891   if (!PPRec)
7892     return nullptr;
7893
7894   IdentifierInfo &II = PP.getIdentifierTable().get(Tok.getRawIdentifier());
7895   if (!II.hadMacroDefinition())
7896     return nullptr;
7897
7898   // Check that the identifier is not one of the macro arguments.
7899   if (std::find(MI->arg_begin(), MI->arg_end(), &II) != MI->arg_end())
7900     return nullptr;
7901
7902   MacroDirective *InnerMD = PP.getLocalMacroDirectiveHistory(&II);
7903   if (!InnerMD)
7904     return nullptr;
7905
7906   return PPRec->findMacroDefinition(InnerMD->getMacroInfo());
7907 }
7908
7909 MacroDefinitionRecord *
7910 cxindex::checkForMacroInMacroDefinition(const MacroInfo *MI, SourceLocation Loc,
7911                                         CXTranslationUnit TU) {
7912   if (Loc.isInvalid() || !MI || !TU)
7913     return nullptr;
7914
7915   if (MI->getNumTokens() == 0)
7916     return nullptr;
7917   ASTUnit *Unit = cxtu::getASTUnit(TU);
7918   Preprocessor &PP = Unit->getPreprocessor();
7919   if (!PP.getPreprocessingRecord())
7920     return nullptr;
7921   Loc = Unit->getSourceManager().getSpellingLoc(Loc);
7922   Token Tok;
7923   if (PP.getRawToken(Loc, Tok))
7924     return nullptr;
7925
7926   return checkForMacroInMacroDefinition(MI, Tok, TU);
7927 }
7928
7929 extern "C" {
7930
7931 CXString clang_getClangVersion() {
7932   return cxstring::createDup(getClangFullVersion());
7933 }
7934
7935 } // end: extern "C"
7936
7937 Logger &cxindex::Logger::operator<<(CXTranslationUnit TU) {
7938   if (TU) {
7939     if (ASTUnit *Unit = cxtu::getASTUnit(TU)) {
7940       LogOS << '<' << Unit->getMainFileName() << '>';
7941       if (Unit->isMainFileAST())
7942         LogOS << " (" << Unit->getASTFileName() << ')';
7943       return *this;
7944     }
7945   } else {
7946     LogOS << "<NULL TU>";
7947   }
7948   return *this;
7949 }
7950
7951 Logger &cxindex::Logger::operator<<(const FileEntry *FE) {
7952   *this << FE->getName();
7953   return *this;
7954 }
7955
7956 Logger &cxindex::Logger::operator<<(CXCursor cursor) {
7957   CXString cursorName = clang_getCursorDisplayName(cursor);
7958   *this << cursorName << "@" << clang_getCursorLocation(cursor);
7959   clang_disposeString(cursorName);
7960   return *this;
7961 }
7962
7963 Logger &cxindex::Logger::operator<<(CXSourceLocation Loc) {
7964   CXFile File;
7965   unsigned Line, Column;
7966   clang_getFileLocation(Loc, &File, &Line, &Column, nullptr);
7967   CXString FileName = clang_getFileName(File);
7968   *this << llvm::format("(%s:%d:%d)", clang_getCString(FileName), Line, Column);
7969   clang_disposeString(FileName);
7970   return *this;
7971 }
7972
7973 Logger &cxindex::Logger::operator<<(CXSourceRange range) {
7974   CXSourceLocation BLoc = clang_getRangeStart(range);
7975   CXSourceLocation ELoc = clang_getRangeEnd(range);
7976
7977   CXFile BFile;
7978   unsigned BLine, BColumn;
7979   clang_getFileLocation(BLoc, &BFile, &BLine, &BColumn, nullptr);
7980
7981   CXFile EFile;
7982   unsigned ELine, EColumn;
7983   clang_getFileLocation(ELoc, &EFile, &ELine, &EColumn, nullptr);
7984
7985   CXString BFileName = clang_getFileName(BFile);
7986   if (BFile == EFile) {
7987     *this << llvm::format("[%s %d:%d-%d:%d]", clang_getCString(BFileName),
7988                          BLine, BColumn, ELine, EColumn);
7989   } else {
7990     CXString EFileName = clang_getFileName(EFile);
7991     *this << llvm::format("[%s:%d:%d - ", clang_getCString(BFileName),
7992                           BLine, BColumn)
7993           << llvm::format("%s:%d:%d]", clang_getCString(EFileName),
7994                           ELine, EColumn);
7995     clang_disposeString(EFileName);
7996   }
7997   clang_disposeString(BFileName);
7998   return *this;
7999 }
8000
8001 Logger &cxindex::Logger::operator<<(CXString Str) {
8002   *this << clang_getCString(Str);
8003   return *this;
8004 }
8005
8006 Logger &cxindex::Logger::operator<<(const llvm::format_object_base &Fmt) {
8007   LogOS << Fmt;
8008   return *this;
8009 }
8010
8011 static llvm::ManagedStatic<llvm::sys::Mutex> LoggingMutex;
8012
8013 cxindex::Logger::~Logger() {
8014   llvm::sys::ScopedLock L(*LoggingMutex);
8015
8016   static llvm::TimeRecord sBeginTR = llvm::TimeRecord::getCurrentTime();
8017
8018   raw_ostream &OS = llvm::errs();
8019   OS << "[libclang:" << Name << ':';
8020
8021 #ifdef USE_DARWIN_THREADS
8022   // TODO: Portability.
8023   mach_port_t tid = pthread_mach_thread_np(pthread_self());
8024   OS << tid << ':';
8025 #endif
8026
8027   llvm::TimeRecord TR = llvm::TimeRecord::getCurrentTime();
8028   OS << llvm::format("%7.4f] ", TR.getWallTime() - sBeginTR.getWallTime());
8029   OS << Msg << '\n';
8030
8031   if (Trace) {
8032     llvm::sys::PrintStackTrace(OS);
8033     OS << "--------------------------------------------------\n";
8034   }
8035 }
8036
8037 #ifdef CLANG_TOOL_EXTRA_BUILD
8038 // This anchor is used to force the linker to link the clang-tidy plugin.
8039 extern volatile int ClangTidyPluginAnchorSource;
8040 static int LLVM_ATTRIBUTE_UNUSED ClangTidyPluginAnchorDestination =
8041     ClangTidyPluginAnchorSource;
8042 #endif