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