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