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