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