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