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