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