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