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