CIndex.cpp revision 6f155de99c59af890817146ec8526bafb6560f1f 
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 && !isa<TranslationUnitDecl>(D))
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  for (ObjCClassDecl::iterator C = D->begin(), CEnd = D->end(); C != CEnd; ++C)
1104    if (Visit(MakeCursorObjCClassRef(C->getInterface(), C->getLocation(), TU)))
1105      return true;
1106
1107  return false;
1108}
1109
1110bool CursorVisitor::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD) {
1111  if (ObjCIvarDecl *Ivar = PD->getPropertyIvarDecl())
1112    return Visit(MakeCursorMemberRef(Ivar, PD->getPropertyIvarDeclLoc(), TU));
1113
1114  return false;
1115}
1116
1117bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) {
1118  return VisitDeclContext(D);
1119}
1120
1121bool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1122  // Visit nested-name-specifier.
1123  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1124    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1125      return true;
1126
1127  return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(),
1128                                      D->getTargetNameLoc(), TU));
1129}
1130
1131bool CursorVisitor::VisitUsingDecl(UsingDecl *D) {
1132  // Visit nested-name-specifier.
1133  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
1134    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1135      return true;
1136  }
1137
1138  if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU)))
1139    return true;
1140
1141  return VisitDeclarationNameInfo(D->getNameInfo());
1142}
1143
1144bool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1145  // Visit nested-name-specifier.
1146  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1147    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1148      return true;
1149
1150  return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(),
1151                                      D->getIdentLocation(), TU));
1152}
1153
1154bool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1155  // Visit nested-name-specifier.
1156  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) {
1157    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1158      return true;
1159  }
1160
1161  return VisitDeclarationNameInfo(D->getNameInfo());
1162}
1163
1164bool CursorVisitor::VisitUnresolvedUsingTypenameDecl(
1165                                               UnresolvedUsingTypenameDecl *D) {
1166  // Visit nested-name-specifier.
1167  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1168    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1169      return true;
1170
1171  return false;
1172}
1173
1174bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) {
1175  switch (Name.getName().getNameKind()) {
1176  case clang::DeclarationName::Identifier:
1177  case clang::DeclarationName::CXXLiteralOperatorName:
1178  case clang::DeclarationName::CXXOperatorName:
1179  case clang::DeclarationName::CXXUsingDirective:
1180    return false;
1181
1182  case clang::DeclarationName::CXXConstructorName:
1183  case clang::DeclarationName::CXXDestructorName:
1184  case clang::DeclarationName::CXXConversionFunctionName:
1185    if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo())
1186      return Visit(TSInfo->getTypeLoc());
1187    return false;
1188
1189  case clang::DeclarationName::ObjCZeroArgSelector:
1190  case clang::DeclarationName::ObjCOneArgSelector:
1191  case clang::DeclarationName::ObjCMultiArgSelector:
1192    // FIXME: Per-identifier location info?
1193    return false;
1194  }
1195
1196  return false;
1197}
1198
1199bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS,
1200                                             SourceRange Range) {
1201  // FIXME: This whole routine is a hack to work around the lack of proper
1202  // source information in nested-name-specifiers (PR5791). Since we do have
1203  // a beginning source location, we can visit the first component of the
1204  // nested-name-specifier, if it's a single-token component.
1205  if (!NNS)
1206    return false;
1207
1208  // Get the first component in the nested-name-specifier.
1209  while (NestedNameSpecifier *Prefix = NNS->getPrefix())
1210    NNS = Prefix;
1211
1212  switch (NNS->getKind()) {
1213  case NestedNameSpecifier::Namespace:
1214    return Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(),
1215                                        TU));
1216
1217  case NestedNameSpecifier::NamespaceAlias:
1218    return Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(),
1219                                        Range.getBegin(), TU));
1220
1221  case NestedNameSpecifier::TypeSpec: {
1222    // If the type has a form where we know that the beginning of the source
1223    // range matches up with a reference cursor. Visit the appropriate reference
1224    // cursor.
1225    const Type *T = NNS->getAsType();
1226    if (const TypedefType *Typedef = dyn_cast<TypedefType>(T))
1227      return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU));
1228    if (const TagType *Tag = dyn_cast<TagType>(T))
1229      return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU));
1230    if (const TemplateSpecializationType *TST
1231                                      = dyn_cast<TemplateSpecializationType>(T))
1232      return VisitTemplateName(TST->getTemplateName(), Range.getBegin());
1233    break;
1234  }
1235
1236  case NestedNameSpecifier::TypeSpecWithTemplate:
1237  case NestedNameSpecifier::Global:
1238  case NestedNameSpecifier::Identifier:
1239    break;
1240  }
1241
1242  return false;
1243}
1244
1245bool
1246CursorVisitor::VisitNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) {
1247  SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
1248  for (; Qualifier; Qualifier = Qualifier.getPrefix())
1249    Qualifiers.push_back(Qualifier);
1250
1251  while (!Qualifiers.empty()) {
1252    NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
1253    NestedNameSpecifier *NNS = Q.getNestedNameSpecifier();
1254    switch (NNS->getKind()) {
1255    case NestedNameSpecifier::Namespace:
1256      if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(),
1257                                       Q.getLocalBeginLoc(),
1258                                       TU)))
1259        return true;
1260
1261      break;
1262
1263    case NestedNameSpecifier::NamespaceAlias:
1264      if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(),
1265                                       Q.getLocalBeginLoc(),
1266                                       TU)))
1267        return true;
1268
1269      break;
1270
1271    case NestedNameSpecifier::TypeSpec:
1272    case NestedNameSpecifier::TypeSpecWithTemplate:
1273      if (Visit(Q.getTypeLoc()))
1274        return true;
1275
1276      break;
1277
1278    case NestedNameSpecifier::Global:
1279    case NestedNameSpecifier::Identifier:
1280      break;
1281    }
1282  }
1283
1284  return false;
1285}
1286
1287bool CursorVisitor::VisitTemplateParameters(
1288                                          const TemplateParameterList *Params) {
1289  if (!Params)
1290    return false;
1291
1292  for (TemplateParameterList::const_iterator P = Params->begin(),
1293                                          PEnd = Params->end();
1294       P != PEnd; ++P) {
1295    if (Visit(MakeCXCursor(*P, TU)))
1296      return true;
1297  }
1298
1299  return false;
1300}
1301
1302bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) {
1303  switch (Name.getKind()) {
1304  case TemplateName::Template:
1305    return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU));
1306
1307  case TemplateName::OverloadedTemplate:
1308    // Visit the overloaded template set.
1309    if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU)))
1310      return true;
1311
1312    return false;
1313
1314  case TemplateName::DependentTemplate:
1315    // FIXME: Visit nested-name-specifier.
1316    return false;
1317
1318  case TemplateName::QualifiedTemplate:
1319    // FIXME: Visit nested-name-specifier.
1320    return Visit(MakeCursorTemplateRef(
1321                                  Name.getAsQualifiedTemplateName()->getDecl(),
1322                                       Loc, TU));
1323
1324  case TemplateName::SubstTemplateTemplateParm:
1325    return Visit(MakeCursorTemplateRef(
1326                         Name.getAsSubstTemplateTemplateParm()->getParameter(),
1327                                       Loc, TU));
1328
1329  case TemplateName::SubstTemplateTemplateParmPack:
1330    return Visit(MakeCursorTemplateRef(
1331                  Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(),
1332                                       Loc, TU));
1333  }
1334
1335  return false;
1336}
1337
1338bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) {
1339  switch (TAL.getArgument().getKind()) {
1340  case TemplateArgument::Null:
1341  case TemplateArgument::Integral:
1342  case TemplateArgument::Pack:
1343    return false;
1344
1345  case TemplateArgument::Type:
1346    if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo())
1347      return Visit(TSInfo->getTypeLoc());
1348    return false;
1349
1350  case TemplateArgument::Declaration:
1351    if (Expr *E = TAL.getSourceDeclExpression())
1352      return Visit(MakeCXCursor(E, StmtParent, TU));
1353    return false;
1354
1355  case TemplateArgument::Expression:
1356    if (Expr *E = TAL.getSourceExpression())
1357      return Visit(MakeCXCursor(E, StmtParent, TU));
1358    return false;
1359
1360  case TemplateArgument::Template:
1361  case TemplateArgument::TemplateExpansion:
1362    if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc()))
1363      return true;
1364
1365    return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(),
1366                             TAL.getTemplateNameLoc());
1367  }
1368
1369  return false;
1370}
1371
1372bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1373  return VisitDeclContext(D);
1374}
1375
1376bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
1377  return Visit(TL.getUnqualifiedLoc());
1378}
1379
1380bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
1381  ASTContext &Context = AU->getASTContext();
1382
1383  // Some builtin types (such as Objective-C's "id", "sel", and
1384  // "Class") have associated declarations. Create cursors for those.
1385  QualType VisitType;
1386  switch (TL.getType()->getAs<BuiltinType>()->getKind()) {
1387  case BuiltinType::Void:
1388  case BuiltinType::Bool:
1389  case BuiltinType::Char_U:
1390  case BuiltinType::UChar:
1391  case BuiltinType::Char16:
1392  case BuiltinType::Char32:
1393  case BuiltinType::UShort:
1394  case BuiltinType::UInt:
1395  case BuiltinType::ULong:
1396  case BuiltinType::ULongLong:
1397  case BuiltinType::UInt128:
1398  case BuiltinType::Char_S:
1399  case BuiltinType::SChar:
1400  case BuiltinType::WChar_U:
1401  case BuiltinType::WChar_S:
1402  case BuiltinType::Short:
1403  case BuiltinType::Int:
1404  case BuiltinType::Long:
1405  case BuiltinType::LongLong:
1406  case BuiltinType::Int128:
1407  case BuiltinType::Float:
1408  case BuiltinType::Double:
1409  case BuiltinType::LongDouble:
1410  case BuiltinType::NullPtr:
1411  case BuiltinType::Overload:
1412  case BuiltinType::BoundMember:
1413  case BuiltinType::Dependent:
1414  case BuiltinType::UnknownAny:
1415    break;
1416
1417  case BuiltinType::ObjCId:
1418    VisitType = Context.getObjCIdType();
1419    break;
1420
1421  case BuiltinType::ObjCClass:
1422    VisitType = Context.getObjCClassType();
1423    break;
1424
1425  case BuiltinType::ObjCSel:
1426    VisitType = Context.getObjCSelType();
1427    break;
1428  }
1429
1430  if (!VisitType.isNull()) {
1431    if (const TypedefType *Typedef = VisitType->getAs<TypedefType>())
1432      return Visit(MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(),
1433                                     TU));
1434  }
1435
1436  return false;
1437}
1438
1439bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
1440  return Visit(MakeCursorTypeRef(TL.getTypedefNameDecl(), TL.getNameLoc(), TU));
1441}
1442
1443bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
1444  return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1445}
1446
1447bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) {
1448  if (TL.isDefinition())
1449    return Visit(MakeCXCursor(TL.getDecl(), TU));
1450
1451  return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1452}
1453
1454bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
1455  return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1456}
1457
1458bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
1459  if (Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU)))
1460    return true;
1461
1462  return false;
1463}
1464
1465bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
1466  if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc()))
1467    return true;
1468
1469  for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
1470    if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I),
1471                                        TU)))
1472      return true;
1473  }
1474
1475  return false;
1476}
1477
1478bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
1479  return Visit(TL.getPointeeLoc());
1480}
1481
1482bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) {
1483  return Visit(TL.getInnerLoc());
1484}
1485
1486bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) {
1487  return Visit(TL.getPointeeLoc());
1488}
1489
1490bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
1491  return Visit(TL.getPointeeLoc());
1492}
1493
1494bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
1495  return Visit(TL.getPointeeLoc());
1496}
1497
1498bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
1499  return Visit(TL.getPointeeLoc());
1500}
1501
1502bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
1503  return Visit(TL.getPointeeLoc());
1504}
1505
1506bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
1507  return Visit(TL.getModifiedLoc());
1508}
1509
1510bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL,
1511                                         bool SkipResultType) {
1512  if (!SkipResultType && Visit(TL.getResultLoc()))
1513    return true;
1514
1515  for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1516    if (Decl *D = TL.getArg(I))
1517      if (Visit(MakeCXCursor(D, TU)))
1518        return true;
1519
1520  return false;
1521}
1522
1523bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) {
1524  if (Visit(TL.getElementLoc()))
1525    return true;
1526
1527  if (Expr *Size = TL.getSizeExpr())
1528    return Visit(MakeCXCursor(Size, StmtParent, TU));
1529
1530  return false;
1531}
1532
1533bool CursorVisitor::VisitTemplateSpecializationTypeLoc(
1534                                             TemplateSpecializationTypeLoc TL) {
1535  // Visit the template name.
1536  if (VisitTemplateName(TL.getTypePtr()->getTemplateName(),
1537                        TL.getTemplateNameLoc()))
1538    return true;
1539
1540  // Visit the template arguments.
1541  for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1542    if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
1543      return true;
1544
1545  return false;
1546}
1547
1548bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
1549  return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU));
1550}
1551
1552bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
1553  if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
1554    return Visit(TSInfo->getTypeLoc());
1555
1556  return false;
1557}
1558
1559bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
1560  if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
1561    return Visit(TSInfo->getTypeLoc());
1562
1563  return false;
1564}
1565
1566bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
1567  if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1568    return true;
1569
1570  return false;
1571}
1572
1573bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc(
1574                                    DependentTemplateSpecializationTypeLoc TL) {
1575  // Visit the nested-name-specifier, if there is one.
1576  if (TL.getQualifierLoc() &&
1577      VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1578    return true;
1579
1580  // Visit the template arguments.
1581  for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1582    if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
1583      return true;
1584
1585  return false;
1586}
1587
1588bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
1589  if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc()))
1590    return true;
1591
1592  return Visit(TL.getNamedTypeLoc());
1593}
1594
1595bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
1596  return Visit(TL.getPatternLoc());
1597}
1598
1599bool CursorVisitor::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
1600  if (Expr *E = TL.getUnderlyingExpr())
1601    return Visit(MakeCXCursor(E, StmtParent, TU));
1602
1603  return false;
1604}
1605
1606bool CursorVisitor::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
1607  return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1608}
1609
1610#define DEFAULT_TYPELOC_IMPL(CLASS, PARENT) \
1611bool CursorVisitor::Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { \
1612  return Visit##PARENT##Loc(TL); \
1613}
1614
1615DEFAULT_TYPELOC_IMPL(Complex, Type)
1616DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType)
1617DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType)
1618DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType)
1619DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType)
1620DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type)
1621DEFAULT_TYPELOC_IMPL(Vector, Type)
1622DEFAULT_TYPELOC_IMPL(ExtVector, VectorType)
1623DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType)
1624DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType)
1625DEFAULT_TYPELOC_IMPL(Record, TagType)
1626DEFAULT_TYPELOC_IMPL(Enum, TagType)
1627DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type)
1628DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type)
1629DEFAULT_TYPELOC_IMPL(Auto, Type)
1630
1631bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) {
1632  // Visit the nested-name-specifier, if present.
1633  if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc())
1634    if (VisitNestedNameSpecifierLoc(QualifierLoc))
1635      return true;
1636
1637  if (D->isDefinition()) {
1638    for (CXXRecordDecl::base_class_iterator I = D->bases_begin(),
1639         E = D->bases_end(); I != E; ++I) {
1640      if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(I, TU)))
1641        return true;
1642    }
1643  }
1644
1645  return VisitTagDecl(D);
1646}
1647
1648bool CursorVisitor::VisitAttributes(Decl *D) {
1649  for (AttrVec::const_iterator i = D->attr_begin(), e = D->attr_end();
1650       i != e; ++i)
1651    if (Visit(MakeCXCursor(*i, D, TU)))
1652        return true;
1653
1654  return false;
1655}
1656
1657//===----------------------------------------------------------------------===//
1658// Data-recursive visitor methods.
1659//===----------------------------------------------------------------------===//
1660
1661namespace {
1662#define DEF_JOB(NAME, DATA, KIND)\
1663class NAME : public VisitorJob {\
1664public:\
1665  NAME(DATA *d, CXCursor parent) : VisitorJob(parent, VisitorJob::KIND, d) {} \
1666  static bool classof(const VisitorJob *VJ) { return VJ->getKind() == KIND; }\
1667  DATA *get() const { return static_cast<DATA*>(data[0]); }\
1668};
1669
1670DEF_JOB(StmtVisit, Stmt, StmtVisitKind)
1671DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind)
1672DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind)
1673DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind)
1674DEF_JOB(ExplicitTemplateArgsVisit, ExplicitTemplateArgumentList,
1675        ExplicitTemplateArgsVisitKind)
1676DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind)
1677#undef DEF_JOB
1678
1679class DeclVisit : public VisitorJob {
1680public:
1681  DeclVisit(Decl *d, CXCursor parent, bool isFirst) :
1682    VisitorJob(parent, VisitorJob::DeclVisitKind,
1683               d, isFirst ? (void*) 1 : (void*) 0) {}
1684  static bool classof(const VisitorJob *VJ) {
1685    return VJ->getKind() == DeclVisitKind;
1686  }
1687  Decl *get() const { return static_cast<Decl*>(data[0]); }
1688  bool isFirst() const { return data[1] ? true : false; }
1689};
1690class TypeLocVisit : public VisitorJob {
1691public:
1692  TypeLocVisit(TypeLoc tl, CXCursor parent) :
1693    VisitorJob(parent, VisitorJob::TypeLocVisitKind,
1694               tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {}
1695
1696  static bool classof(const VisitorJob *VJ) {
1697    return VJ->getKind() == TypeLocVisitKind;
1698  }
1699
1700  TypeLoc get() const {
1701    QualType T = QualType::getFromOpaquePtr(data[0]);
1702    return TypeLoc(T, data[1]);
1703  }
1704};
1705
1706class LabelRefVisit : public VisitorJob {
1707public:
1708  LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent)
1709    : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD,
1710                 labelLoc.getPtrEncoding()) {}
1711
1712  static bool classof(const VisitorJob *VJ) {
1713    return VJ->getKind() == VisitorJob::LabelRefVisitKind;
1714  }
1715  LabelDecl *get() const { return static_cast<LabelDecl*>(data[0]); }
1716  SourceLocation getLoc() const {
1717    return SourceLocation::getFromPtrEncoding(data[1]); }
1718};
1719
1720class NestedNameSpecifierLocVisit : public VisitorJob {
1721public:
1722  NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent)
1723    : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind,
1724                 Qualifier.getNestedNameSpecifier(),
1725                 Qualifier.getOpaqueData()) { }
1726
1727  static bool classof(const VisitorJob *VJ) {
1728    return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind;
1729  }
1730
1731  NestedNameSpecifierLoc get() const {
1732    return NestedNameSpecifierLoc(static_cast<NestedNameSpecifier*>(data[0]),
1733                                  data[1]);
1734  }
1735};
1736
1737class DeclarationNameInfoVisit : public VisitorJob {
1738public:
1739  DeclarationNameInfoVisit(Stmt *S, CXCursor parent)
1740    : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {}
1741  static bool classof(const VisitorJob *VJ) {
1742    return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind;
1743  }
1744  DeclarationNameInfo get() const {
1745    Stmt *S = static_cast<Stmt*>(data[0]);
1746    switch (S->getStmtClass()) {
1747    default:
1748      llvm_unreachable("Unhandled Stmt");
1749    case Stmt::CXXDependentScopeMemberExprClass:
1750      return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo();
1751    case Stmt::DependentScopeDeclRefExprClass:
1752      return cast<DependentScopeDeclRefExpr>(S)->getNameInfo();
1753    }
1754  }
1755};
1756class MemberRefVisit : public VisitorJob {
1757public:
1758  MemberRefVisit(FieldDecl *D, SourceLocation L, CXCursor parent)
1759    : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D,
1760                 L.getPtrEncoding()) {}
1761  static bool classof(const VisitorJob *VJ) {
1762    return VJ->getKind() == VisitorJob::MemberRefVisitKind;
1763  }
1764  FieldDecl *get() const {
1765    return static_cast<FieldDecl*>(data[0]);
1766  }
1767  SourceLocation getLoc() const {
1768    return SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[1]);
1769  }
1770};
1771class EnqueueVisitor : public StmtVisitor<EnqueueVisitor, void> {
1772  VisitorWorkList &WL;
1773  CXCursor Parent;
1774public:
1775  EnqueueVisitor(VisitorWorkList &wl, CXCursor parent)
1776    : WL(wl), Parent(parent) {}
1777
1778  void VisitAddrLabelExpr(AddrLabelExpr *E);
1779  void VisitBlockExpr(BlockExpr *B);
1780  void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
1781  void VisitCompoundStmt(CompoundStmt *S);
1782  void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { /* Do nothing. */ }
1783  void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
1784  void VisitCXXNewExpr(CXXNewExpr *E);
1785  void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
1786  void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
1787  void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
1788  void VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
1789  void VisitCXXTypeidExpr(CXXTypeidExpr *E);
1790  void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
1791  void VisitCXXUuidofExpr(CXXUuidofExpr *E);
1792  void VisitDeclRefExpr(DeclRefExpr *D);
1793  void VisitDeclStmt(DeclStmt *S);
1794  void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
1795  void VisitDesignatedInitExpr(DesignatedInitExpr *E);
1796  void VisitExplicitCastExpr(ExplicitCastExpr *E);
1797  void VisitForStmt(ForStmt *FS);
1798  void VisitGotoStmt(GotoStmt *GS);
1799  void VisitIfStmt(IfStmt *If);
1800  void VisitInitListExpr(InitListExpr *IE);
1801  void VisitMemberExpr(MemberExpr *M);
1802  void VisitOffsetOfExpr(OffsetOfExpr *E);
1803  void VisitObjCEncodeExpr(ObjCEncodeExpr *E);
1804  void VisitObjCMessageExpr(ObjCMessageExpr *M);
1805  void VisitOverloadExpr(OverloadExpr *E);
1806  void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
1807  void VisitStmt(Stmt *S);
1808  void VisitSwitchStmt(SwitchStmt *S);
1809  void VisitWhileStmt(WhileStmt *W);
1810  void VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E);
1811  void VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E);
1812  void VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
1813  void VisitExpressionTraitExpr(ExpressionTraitExpr *E);
1814  void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *U);
1815  void VisitVAArgExpr(VAArgExpr *E);
1816  void VisitSizeOfPackExpr(SizeOfPackExpr *E);
1817
1818private:
1819  void AddDeclarationNameInfo(Stmt *S);
1820  void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier);
1821  void AddExplicitTemplateArgs(const ExplicitTemplateArgumentList *A);
1822  void AddMemberRef(FieldDecl *D, SourceLocation L);
1823  void AddStmt(Stmt *S);
1824  void AddDecl(Decl *D, bool isFirst = true);
1825  void AddTypeLoc(TypeSourceInfo *TI);
1826  void EnqueueChildren(Stmt *S);
1827};
1828} // end anonyous namespace
1829
1830void EnqueueVisitor::AddDeclarationNameInfo(Stmt *S) {
1831  // 'S' should always be non-null, since it comes from the
1832  // statement we are visiting.
1833  WL.push_back(DeclarationNameInfoVisit(S, Parent));
1834}
1835
1836void
1837EnqueueVisitor::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) {
1838  if (Qualifier)
1839    WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent));
1840}
1841
1842void EnqueueVisitor::AddStmt(Stmt *S) {
1843  if (S)
1844    WL.push_back(StmtVisit(S, Parent));
1845}
1846void EnqueueVisitor::AddDecl(Decl *D, bool isFirst) {
1847  if (D)
1848    WL.push_back(DeclVisit(D, Parent, isFirst));
1849}
1850void EnqueueVisitor::
1851  AddExplicitTemplateArgs(const ExplicitTemplateArgumentList *A) {
1852  if (A)
1853    WL.push_back(ExplicitTemplateArgsVisit(
1854                        const_cast<ExplicitTemplateArgumentList*>(A), Parent));
1855}
1856void EnqueueVisitor::AddMemberRef(FieldDecl *D, SourceLocation L) {
1857  if (D)
1858    WL.push_back(MemberRefVisit(D, L, Parent));
1859}
1860void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) {
1861  if (TI)
1862    WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent));
1863 }
1864void EnqueueVisitor::EnqueueChildren(Stmt *S) {
1865  unsigned size = WL.size();
1866  for (Stmt::child_range Child = S->children(); Child; ++Child) {
1867    AddStmt(*Child);
1868  }
1869  if (size == WL.size())
1870    return;
1871  // Now reverse the entries we just added.  This will match the DFS
1872  // ordering performed by the worklist.
1873  VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
1874  std::reverse(I, E);
1875}
1876void EnqueueVisitor::VisitAddrLabelExpr(AddrLabelExpr *E) {
1877  WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent));
1878}
1879void EnqueueVisitor::VisitBlockExpr(BlockExpr *B) {
1880  AddDecl(B->getBlockDecl());
1881}
1882void EnqueueVisitor::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1883  EnqueueChildren(E);
1884  AddTypeLoc(E->getTypeSourceInfo());
1885}
1886void EnqueueVisitor::VisitCompoundStmt(CompoundStmt *S) {
1887  for (CompoundStmt::reverse_body_iterator I = S->body_rbegin(),
1888        E = S->body_rend(); I != E; ++I) {
1889    AddStmt(*I);
1890  }
1891}
1892void EnqueueVisitor::
1893VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) {
1894  AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs());
1895  AddDeclarationNameInfo(E);
1896  if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
1897    AddNestedNameSpecifierLoc(QualifierLoc);
1898  if (!E->isImplicitAccess())
1899    AddStmt(E->getBase());
1900}
1901void EnqueueVisitor::VisitCXXNewExpr(CXXNewExpr *E) {
1902  // Enqueue the initializer or constructor arguments.
1903  for (unsigned I = E->getNumConstructorArgs(); I > 0; --I)
1904    AddStmt(E->getConstructorArg(I-1));
1905  // Enqueue the array size, if any.
1906  AddStmt(E->getArraySize());
1907  // Enqueue the allocated type.
1908  AddTypeLoc(E->getAllocatedTypeSourceInfo());
1909  // Enqueue the placement arguments.
1910  for (unsigned I = E->getNumPlacementArgs(); I > 0; --I)
1911    AddStmt(E->getPlacementArg(I-1));
1912}
1913void EnqueueVisitor::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *CE) {
1914  for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I)
1915    AddStmt(CE->getArg(I-1));
1916  AddStmt(CE->getCallee());
1917  AddStmt(CE->getArg(0));
1918}
1919void EnqueueVisitor::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1920  // Visit the name of the type being destroyed.
1921  AddTypeLoc(E->getDestroyedTypeInfo());
1922  // Visit the scope type that looks disturbingly like the nested-name-specifier
1923  // but isn't.
1924  AddTypeLoc(E->getScopeTypeInfo());
1925  // Visit the nested-name-specifier.
1926  if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc())
1927    AddNestedNameSpecifierLoc(QualifierLoc);
1928  // Visit base expression.
1929  AddStmt(E->getBase());
1930}
1931void EnqueueVisitor::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1932  AddTypeLoc(E->getTypeSourceInfo());
1933}
1934void EnqueueVisitor::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1935  EnqueueChildren(E);
1936  AddTypeLoc(E->getTypeSourceInfo());
1937}
1938void EnqueueVisitor::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1939  EnqueueChildren(E);
1940  if (E->isTypeOperand())
1941    AddTypeLoc(E->getTypeOperandSourceInfo());
1942}
1943
1944void EnqueueVisitor::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr
1945                                                     *E) {
1946  EnqueueChildren(E);
1947  AddTypeLoc(E->getTypeSourceInfo());
1948}
1949void EnqueueVisitor::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1950  EnqueueChildren(E);
1951  if (E->isTypeOperand())
1952    AddTypeLoc(E->getTypeOperandSourceInfo());
1953}
1954void EnqueueVisitor::VisitDeclRefExpr(DeclRefExpr *DR) {
1955  if (DR->hasExplicitTemplateArgs()) {
1956    AddExplicitTemplateArgs(&DR->getExplicitTemplateArgs());
1957  }
1958  WL.push_back(DeclRefExprParts(DR, Parent));
1959}
1960void EnqueueVisitor::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1961  AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs());
1962  AddDeclarationNameInfo(E);
1963  AddNestedNameSpecifierLoc(E->getQualifierLoc());
1964}
1965void EnqueueVisitor::VisitDeclStmt(DeclStmt *S) {
1966  unsigned size = WL.size();
1967  bool isFirst = true;
1968  for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end();
1969       D != DEnd; ++D) {
1970    AddDecl(*D, isFirst);
1971    isFirst = false;
1972  }
1973  if (size == WL.size())
1974    return;
1975  // Now reverse the entries we just added.  This will match the DFS
1976  // ordering performed by the worklist.
1977  VisitorWorkList::iterator I = WL.begin() + size, E = WL.end();
1978  std::reverse(I, E);
1979}
1980void EnqueueVisitor::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1981  AddStmt(E->getInit());
1982  typedef DesignatedInitExpr::Designator Designator;
1983  for (DesignatedInitExpr::reverse_designators_iterator
1984         D = E->designators_rbegin(), DEnd = E->designators_rend();
1985         D != DEnd; ++D) {
1986    if (D->isFieldDesignator()) {
1987      if (FieldDecl *Field = D->getField())
1988        AddMemberRef(Field, D->getFieldLoc());
1989      continue;
1990    }
1991    if (D->isArrayDesignator()) {
1992      AddStmt(E->getArrayIndex(*D));
1993      continue;
1994    }
1995    assert(D->isArrayRangeDesignator() && "Unknown designator kind");
1996    AddStmt(E->getArrayRangeEnd(*D));
1997    AddStmt(E->getArrayRangeStart(*D));
1998  }
1999}
2000void EnqueueVisitor::VisitExplicitCastExpr(ExplicitCastExpr *E) {
2001  EnqueueChildren(E);
2002  AddTypeLoc(E->getTypeInfoAsWritten());
2003}
2004void EnqueueVisitor::VisitForStmt(ForStmt *FS) {
2005  AddStmt(FS->getBody());
2006  AddStmt(FS->getInc());
2007  AddStmt(FS->getCond());
2008  AddDecl(FS->getConditionVariable());
2009  AddStmt(FS->getInit());
2010}
2011void EnqueueVisitor::VisitGotoStmt(GotoStmt *GS) {
2012  WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent));
2013}
2014void EnqueueVisitor::VisitIfStmt(IfStmt *If) {
2015  AddStmt(If->getElse());
2016  AddStmt(If->getThen());
2017  AddStmt(If->getCond());
2018  AddDecl(If->getConditionVariable());
2019}
2020void EnqueueVisitor::VisitInitListExpr(InitListExpr *IE) {
2021  // We care about the syntactic form of the initializer list, only.
2022  if (InitListExpr *Syntactic = IE->getSyntacticForm())
2023    IE = Syntactic;
2024  EnqueueChildren(IE);
2025}
2026void EnqueueVisitor::VisitMemberExpr(MemberExpr *M) {
2027  WL.push_back(MemberExprParts(M, Parent));
2028
2029  // If the base of the member access expression is an implicit 'this', don't
2030  // visit it.
2031  // FIXME: If we ever want to show these implicit accesses, this will be
2032  // unfortunate. However, clang_getCursor() relies on this behavior.
2033  if (!M->isImplicitAccess())
2034    AddStmt(M->getBase());
2035}
2036void EnqueueVisitor::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
2037  AddTypeLoc(E->getEncodedTypeSourceInfo());
2038}
2039void EnqueueVisitor::VisitObjCMessageExpr(ObjCMessageExpr *M) {
2040  EnqueueChildren(M);
2041  AddTypeLoc(M->getClassReceiverTypeInfo());
2042}
2043void EnqueueVisitor::VisitOffsetOfExpr(OffsetOfExpr *E) {
2044  // Visit the components of the offsetof expression.
2045  for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) {
2046    typedef OffsetOfExpr::OffsetOfNode OffsetOfNode;
2047    const OffsetOfNode &Node = E->getComponent(I-1);
2048    switch (Node.getKind()) {
2049    case OffsetOfNode::Array:
2050      AddStmt(E->getIndexExpr(Node.getArrayExprIndex()));
2051      break;
2052    case OffsetOfNode::Field:
2053      AddMemberRef(Node.getField(), Node.getSourceRange().getEnd());
2054      break;
2055    case OffsetOfNode::Identifier:
2056    case OffsetOfNode::Base:
2057      continue;
2058    }
2059  }
2060  // Visit the type into which we're computing the offset.
2061  AddTypeLoc(E->getTypeSourceInfo());
2062}
2063void EnqueueVisitor::VisitOverloadExpr(OverloadExpr *E) {
2064  AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs());
2065  WL.push_back(OverloadExprParts(E, Parent));
2066}
2067void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr(
2068                                              UnaryExprOrTypeTraitExpr *E) {
2069  EnqueueChildren(E);
2070  if (E->isArgumentType())
2071    AddTypeLoc(E->getArgumentTypeInfo());
2072}
2073void EnqueueVisitor::VisitStmt(Stmt *S) {
2074  EnqueueChildren(S);
2075}
2076void EnqueueVisitor::VisitSwitchStmt(SwitchStmt *S) {
2077  AddStmt(S->getBody());
2078  AddStmt(S->getCond());
2079  AddDecl(S->getConditionVariable());
2080}
2081
2082void EnqueueVisitor::VisitWhileStmt(WhileStmt *W) {
2083  AddStmt(W->getBody());
2084  AddStmt(W->getCond());
2085  AddDecl(W->getConditionVariable());
2086}
2087
2088void EnqueueVisitor::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
2089  AddTypeLoc(E->getQueriedTypeSourceInfo());
2090}
2091
2092void EnqueueVisitor::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
2093  AddTypeLoc(E->getRhsTypeSourceInfo());
2094  AddTypeLoc(E->getLhsTypeSourceInfo());
2095}
2096
2097void EnqueueVisitor::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2098  AddTypeLoc(E->getQueriedTypeSourceInfo());
2099}
2100
2101void EnqueueVisitor::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2102  EnqueueChildren(E);
2103}
2104
2105void EnqueueVisitor::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *U) {
2106  VisitOverloadExpr(U);
2107  if (!U->isImplicitAccess())
2108    AddStmt(U->getBase());
2109}
2110void EnqueueVisitor::VisitVAArgExpr(VAArgExpr *E) {
2111  AddStmt(E->getSubExpr());
2112  AddTypeLoc(E->getWrittenTypeInfo());
2113}
2114void EnqueueVisitor::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2115  WL.push_back(SizeOfPackExprParts(E, Parent));
2116}
2117
2118void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, Stmt *S) {
2119  EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU)).Visit(S);
2120}
2121
2122bool CursorVisitor::IsInRegionOfInterest(CXCursor C) {
2123  if (RegionOfInterest.isValid()) {
2124    SourceRange Range = getRawCursorExtent(C);
2125    if (Range.isInvalid() || CompareRegionOfInterest(Range))
2126      return false;
2127  }
2128  return true;
2129}
2130
2131bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) {
2132  while (!WL.empty()) {
2133    // Dequeue the worklist item.
2134    VisitorJob LI = WL.back();
2135    WL.pop_back();
2136
2137    // Set the Parent field, then back to its old value once we're done.
2138    SetParentRAII SetParent(Parent, StmtParent, LI.getParent());
2139
2140    switch (LI.getKind()) {
2141      case VisitorJob::DeclVisitKind: {
2142        Decl *D = cast<DeclVisit>(&LI)->get();
2143        if (!D)
2144          continue;
2145
2146        // For now, perform default visitation for Decls.
2147        if (Visit(MakeCXCursor(D, TU, cast<DeclVisit>(&LI)->isFirst())))
2148            return true;
2149
2150        continue;
2151      }
2152      case VisitorJob::ExplicitTemplateArgsVisitKind: {
2153        const ExplicitTemplateArgumentList *ArgList =
2154          cast<ExplicitTemplateArgsVisit>(&LI)->get();
2155        for (const TemplateArgumentLoc *Arg = ArgList->getTemplateArgs(),
2156               *ArgEnd = Arg + ArgList->NumTemplateArgs;
2157               Arg != ArgEnd; ++Arg) {
2158          if (VisitTemplateArgumentLoc(*Arg))
2159            return true;
2160        }
2161        continue;
2162      }
2163      case VisitorJob::TypeLocVisitKind: {
2164        // Perform default visitation for TypeLocs.
2165        if (Visit(cast<TypeLocVisit>(&LI)->get()))
2166          return true;
2167        continue;
2168      }
2169      case VisitorJob::LabelRefVisitKind: {
2170        LabelDecl *LS = cast<LabelRefVisit>(&LI)->get();
2171        if (LabelStmt *stmt = LS->getStmt()) {
2172          if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(),
2173                                       TU))) {
2174            return true;
2175          }
2176        }
2177        continue;
2178      }
2179
2180      case VisitorJob::NestedNameSpecifierLocVisitKind: {
2181        NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI);
2182        if (VisitNestedNameSpecifierLoc(V->get()))
2183          return true;
2184        continue;
2185      }
2186
2187      case VisitorJob::DeclarationNameInfoVisitKind: {
2188        if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI)
2189                                     ->get()))
2190          return true;
2191        continue;
2192      }
2193      case VisitorJob::MemberRefVisitKind: {
2194        MemberRefVisit *V = cast<MemberRefVisit>(&LI);
2195        if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU)))
2196          return true;
2197        continue;
2198      }
2199      case VisitorJob::StmtVisitKind: {
2200        Stmt *S = cast<StmtVisit>(&LI)->get();
2201        if (!S)
2202          continue;
2203
2204        // Update the current cursor.
2205        CXCursor Cursor = MakeCXCursor(S, StmtParent, TU);
2206        if (!IsInRegionOfInterest(Cursor))
2207          continue;
2208        switch (Visitor(Cursor, Parent, ClientData)) {
2209          case CXChildVisit_Break: return true;
2210          case CXChildVisit_Continue: break;
2211          case CXChildVisit_Recurse:
2212            EnqueueWorkList(WL, S);
2213            break;
2214        }
2215        continue;
2216      }
2217      case VisitorJob::MemberExprPartsKind: {
2218        // Handle the other pieces in the MemberExpr besides the base.
2219        MemberExpr *M = cast<MemberExprParts>(&LI)->get();
2220
2221        // Visit the nested-name-specifier
2222        if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc())
2223          if (VisitNestedNameSpecifierLoc(QualifierLoc))
2224            return true;
2225
2226        // Visit the declaration name.
2227        if (VisitDeclarationNameInfo(M->getMemberNameInfo()))
2228          return true;
2229
2230        // Visit the explicitly-specified template arguments, if any.
2231        if (M->hasExplicitTemplateArgs()) {
2232          for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(),
2233               *ArgEnd = Arg + M->getNumTemplateArgs();
2234               Arg != ArgEnd; ++Arg) {
2235            if (VisitTemplateArgumentLoc(*Arg))
2236              return true;
2237          }
2238        }
2239        continue;
2240      }
2241      case VisitorJob::DeclRefExprPartsKind: {
2242        DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get();
2243        // Visit nested-name-specifier, if present.
2244        if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc())
2245          if (VisitNestedNameSpecifierLoc(QualifierLoc))
2246            return true;
2247        // Visit declaration name.
2248        if (VisitDeclarationNameInfo(DR->getNameInfo()))
2249          return true;
2250        continue;
2251      }
2252      case VisitorJob::OverloadExprPartsKind: {
2253        OverloadExpr *O = cast<OverloadExprParts>(&LI)->get();
2254        // Visit the nested-name-specifier.
2255        if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc())
2256          if (VisitNestedNameSpecifierLoc(QualifierLoc))
2257            return true;
2258        // Visit the declaration name.
2259        if (VisitDeclarationNameInfo(O->getNameInfo()))
2260          return true;
2261        // Visit the overloaded declaration reference.
2262        if (Visit(MakeCursorOverloadedDeclRef(O, TU)))
2263          return true;
2264        continue;
2265      }
2266      case VisitorJob::SizeOfPackExprPartsKind: {
2267        SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get();
2268        NamedDecl *Pack = E->getPack();
2269        if (isa<TemplateTypeParmDecl>(Pack)) {
2270          if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack),
2271                                      E->getPackLoc(), TU)))
2272            return true;
2273
2274          continue;
2275        }
2276
2277        if (isa<TemplateTemplateParmDecl>(Pack)) {
2278          if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack),
2279                                          E->getPackLoc(), TU)))
2280            return true;
2281
2282          continue;
2283        }
2284
2285        // Non-type template parameter packs and function parameter packs are
2286        // treated like DeclRefExpr cursors.
2287        continue;
2288      }
2289    }
2290  }
2291  return false;
2292}
2293
2294bool CursorVisitor::Visit(Stmt *S) {
2295  VisitorWorkList *WL = 0;
2296  if (!WorkListFreeList.empty()) {
2297    WL = WorkListFreeList.back();
2298    WL->clear();
2299    WorkListFreeList.pop_back();
2300  }
2301  else {
2302    WL = new VisitorWorkList();
2303    WorkListCache.push_back(WL);
2304  }
2305  EnqueueWorkList(*WL, S);
2306  bool result = RunVisitorWorkList(*WL);
2307  WorkListFreeList.push_back(WL);
2308  return result;
2309}
2310
2311namespace {
2312typedef llvm::SmallVector<SourceRange, 4> RefNamePieces;
2313RefNamePieces buildPieces(unsigned NameFlags, bool IsMemberRefExpr,
2314                          const DeclarationNameInfo &NI,
2315                          const SourceRange &QLoc,
2316                          const ExplicitTemplateArgumentList *TemplateArgs = 0){
2317  const bool WantQualifier = NameFlags & CXNameRange_WantQualifier;
2318  const bool WantTemplateArgs = NameFlags & CXNameRange_WantTemplateArgs;
2319  const bool WantSinglePiece = NameFlags & CXNameRange_WantSinglePiece;
2320
2321  const DeclarationName::NameKind Kind = NI.getName().getNameKind();
2322
2323  RefNamePieces Pieces;
2324
2325  if (WantQualifier && QLoc.isValid())
2326    Pieces.push_back(QLoc);
2327
2328  if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr)
2329    Pieces.push_back(NI.getLoc());
2330
2331  if (WantTemplateArgs && TemplateArgs)
2332    Pieces.push_back(SourceRange(TemplateArgs->LAngleLoc,
2333                                 TemplateArgs->RAngleLoc));
2334
2335  if (Kind == DeclarationName::CXXOperatorName) {
2336    Pieces.push_back(SourceLocation::getFromRawEncoding(
2337                       NI.getInfo().CXXOperatorName.BeginOpNameLoc));
2338    Pieces.push_back(SourceLocation::getFromRawEncoding(
2339                       NI.getInfo().CXXOperatorName.EndOpNameLoc));
2340  }
2341
2342  if (WantSinglePiece) {
2343    SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd());
2344    Pieces.clear();
2345    Pieces.push_back(R);
2346  }
2347
2348  return Pieces;
2349}
2350}
2351
2352//===----------------------------------------------------------------------===//
2353// Misc. API hooks.
2354//===----------------------------------------------------------------------===//
2355
2356static llvm::sys::Mutex EnableMultithreadingMutex;
2357static bool EnabledMultithreading;
2358
2359extern "C" {
2360CXIndex clang_createIndex(int excludeDeclarationsFromPCH,
2361                          int displayDiagnostics) {
2362  // Disable pretty stack trace functionality, which will otherwise be a very
2363  // poor citizen of the world and set up all sorts of signal handlers.
2364  llvm::DisablePrettyStackTrace = true;
2365
2366  // We use crash recovery to make some of our APIs more reliable, implicitly
2367  // enable it.
2368  llvm::CrashRecoveryContext::Enable();
2369
2370  // Enable support for multithreading in LLVM.
2371  {
2372    llvm::sys::ScopedLock L(EnableMultithreadingMutex);
2373    if (!EnabledMultithreading) {
2374      llvm::llvm_start_multithreaded();
2375      EnabledMultithreading = true;
2376    }
2377  }
2378
2379  CIndexer *CIdxr = new CIndexer();
2380  if (excludeDeclarationsFromPCH)
2381    CIdxr->setOnlyLocalDecls();
2382  if (displayDiagnostics)
2383    CIdxr->setDisplayDiagnostics();
2384  return CIdxr;
2385}
2386
2387void clang_disposeIndex(CXIndex CIdx) {
2388  if (CIdx)
2389    delete static_cast<CIndexer *>(CIdx);
2390}
2391
2392void clang_toggleCrashRecovery(unsigned isEnabled) {
2393  if (isEnabled)
2394    llvm::CrashRecoveryContext::Enable();
2395  else
2396    llvm::CrashRecoveryContext::Disable();
2397}
2398
2399CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx,
2400                                              const char *ast_filename) {
2401  if (!CIdx)
2402    return 0;
2403
2404  CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
2405  FileSystemOptions FileSystemOpts;
2406  FileSystemOpts.WorkingDir = CXXIdx->getWorkingDirectory();
2407
2408  llvm::IntrusiveRefCntPtr<Diagnostic> Diags;
2409  ASTUnit *TU = ASTUnit::LoadFromASTFile(ast_filename, Diags, FileSystemOpts,
2410                                  CXXIdx->getOnlyLocalDecls(),
2411                                  0, 0, true);
2412  return MakeCXTranslationUnit(TU);
2413}
2414
2415unsigned clang_defaultEditingTranslationUnitOptions() {
2416  return CXTranslationUnit_PrecompiledPreamble |
2417         CXTranslationUnit_CacheCompletionResults |
2418         CXTranslationUnit_CXXPrecompiledPreamble |
2419         CXTranslationUnit_CXXChainedPCH;
2420}
2421
2422CXTranslationUnit
2423clang_createTranslationUnitFromSourceFile(CXIndex CIdx,
2424                                          const char *source_filename,
2425                                          int num_command_line_args,
2426                                          const char * const *command_line_args,
2427                                          unsigned num_unsaved_files,
2428                                          struct CXUnsavedFile *unsaved_files) {
2429  unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord |
2430                     CXTranslationUnit_NestedMacroExpansions;
2431  return clang_parseTranslationUnit(CIdx, source_filename,
2432                                    command_line_args, num_command_line_args,
2433                                    unsaved_files, num_unsaved_files,
2434                                    Options);
2435}
2436
2437struct ParseTranslationUnitInfo {
2438  CXIndex CIdx;
2439  const char *source_filename;
2440  const char *const *command_line_args;
2441  int num_command_line_args;
2442  struct CXUnsavedFile *unsaved_files;
2443  unsigned num_unsaved_files;
2444  unsigned options;
2445  CXTranslationUnit result;
2446};
2447static void clang_parseTranslationUnit_Impl(void *UserData) {
2448  ParseTranslationUnitInfo *PTUI =
2449    static_cast<ParseTranslationUnitInfo*>(UserData);
2450  CXIndex CIdx = PTUI->CIdx;
2451  const char *source_filename = PTUI->source_filename;
2452  const char * const *command_line_args = PTUI->command_line_args;
2453  int num_command_line_args = PTUI->num_command_line_args;
2454  struct CXUnsavedFile *unsaved_files = PTUI->unsaved_files;
2455  unsigned num_unsaved_files = PTUI->num_unsaved_files;
2456  unsigned options = PTUI->options;
2457  PTUI->result = 0;
2458
2459  if (!CIdx)
2460    return;
2461
2462  CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
2463
2464  bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble;
2465  bool CompleteTranslationUnit
2466    = ((options & CXTranslationUnit_Incomplete) == 0);
2467  bool CacheCodeCompetionResults
2468    = options & CXTranslationUnit_CacheCompletionResults;
2469  bool CXXPrecompilePreamble
2470    = options & CXTranslationUnit_CXXPrecompiledPreamble;
2471  bool CXXChainedPCH
2472    = options & CXTranslationUnit_CXXChainedPCH;
2473
2474  // Configure the diagnostics.
2475  DiagnosticOptions DiagOpts;
2476  llvm::IntrusiveRefCntPtr<Diagnostic>
2477    Diags(CompilerInstance::createDiagnostics(DiagOpts, num_command_line_args,
2478                                                command_line_args));
2479
2480  // Recover resources if we crash before exiting this function.
2481  llvm::CrashRecoveryContextCleanupRegistrar<Diagnostic,
2482    llvm::CrashRecoveryContextReleaseRefCleanup<Diagnostic> >
2483    DiagCleanup(Diags.getPtr());
2484
2485  llvm::OwningPtr<std::vector<ASTUnit::RemappedFile> >
2486    RemappedFiles(new std::vector<ASTUnit::RemappedFile>());
2487
2488  // Recover resources if we crash before exiting this function.
2489  llvm::CrashRecoveryContextCleanupRegistrar<
2490    std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
2491
2492  for (unsigned I = 0; I != num_unsaved_files; ++I) {
2493    StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length);
2494    const llvm::MemoryBuffer *Buffer
2495      = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename);
2496    RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename,
2497                                            Buffer));
2498  }
2499
2500  llvm::OwningPtr<std::vector<const char *> >
2501    Args(new std::vector<const char*>());
2502
2503  // Recover resources if we crash before exiting this method.
2504  llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> >
2505    ArgsCleanup(Args.get());
2506
2507  // Since the Clang C library is primarily used by batch tools dealing with
2508  // (often very broken) source code, where spell-checking can have a
2509  // significant negative impact on performance (particularly when
2510  // precompiled headers are involved), we disable it by default.
2511  // Only do this if we haven't found a spell-checking-related argument.
2512  bool FoundSpellCheckingArgument = false;
2513  for (int I = 0; I != num_command_line_args; ++I) {
2514    if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 ||
2515        strcmp(command_line_args[I], "-fspell-checking") == 0) {
2516      FoundSpellCheckingArgument = true;
2517      break;
2518    }
2519  }
2520  if (!FoundSpellCheckingArgument)
2521    Args->push_back("-fno-spell-checking");
2522
2523  Args->insert(Args->end(), command_line_args,
2524               command_line_args + num_command_line_args);
2525
2526  // The 'source_filename' argument is optional.  If the caller does not
2527  // specify it then it is assumed that the source file is specified
2528  // in the actual argument list.
2529  // Put the source file after command_line_args otherwise if '-x' flag is
2530  // present it will be unused.
2531  if (source_filename)
2532    Args->push_back(source_filename);
2533
2534  // Do we need the detailed preprocessing record?
2535  bool NestedMacroExpansions = false;
2536  if (options & CXTranslationUnit_DetailedPreprocessingRecord) {
2537    Args->push_back("-Xclang");
2538    Args->push_back("-detailed-preprocessing-record");
2539    NestedMacroExpansions
2540      = (options & CXTranslationUnit_NestedMacroExpansions);
2541  }
2542
2543  unsigned NumErrors = Diags->getClient()->getNumErrors();
2544  llvm::OwningPtr<ASTUnit> Unit(
2545    ASTUnit::LoadFromCommandLine(Args->size() ? &(*Args)[0] : 0
2546                                 /* vector::data() not portable */,
2547                                 Args->size() ? (&(*Args)[0] + Args->size()) :0,
2548                                 Diags,
2549                                 CXXIdx->getClangResourcesPath(),
2550                                 CXXIdx->getOnlyLocalDecls(),
2551                                 /*CaptureDiagnostics=*/true,
2552                                 RemappedFiles->size() ? &(*RemappedFiles)[0]:0,
2553                                 RemappedFiles->size(),
2554                                 /*RemappedFilesKeepOriginalName=*/true,
2555                                 PrecompilePreamble,
2556                                 CompleteTranslationUnit,
2557                                 CacheCodeCompetionResults,
2558                                 CXXPrecompilePreamble,
2559                                 CXXChainedPCH,
2560                                 NestedMacroExpansions));
2561
2562  if (NumErrors != Diags->getClient()->getNumErrors()) {
2563    // Make sure to check that 'Unit' is non-NULL.
2564    if (CXXIdx->getDisplayDiagnostics() && Unit.get()) {
2565      for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(),
2566                                      DEnd = Unit->stored_diag_end();
2567           D != DEnd; ++D) {
2568        CXStoredDiagnostic Diag(*D, Unit->getASTContext().getLangOptions());
2569        CXString Msg = clang_formatDiagnostic(&Diag,
2570                                    clang_defaultDiagnosticDisplayOptions());
2571        fprintf(stderr, "%s\n", clang_getCString(Msg));
2572        clang_disposeString(Msg);
2573      }
2574#ifdef LLVM_ON_WIN32
2575      // On Windows, force a flush, since there may be multiple copies of
2576      // stderr and stdout in the file system, all with different buffers
2577      // but writing to the same device.
2578      fflush(stderr);
2579#endif
2580    }
2581  }
2582
2583  PTUI->result = MakeCXTranslationUnit(Unit.take());
2584}
2585CXTranslationUnit clang_parseTranslationUnit(CXIndex CIdx,
2586                                             const char *source_filename,
2587                                         const char * const *command_line_args,
2588                                             int num_command_line_args,
2589                                            struct CXUnsavedFile *unsaved_files,
2590                                             unsigned num_unsaved_files,
2591                                             unsigned options) {
2592  ParseTranslationUnitInfo PTUI = { CIdx, source_filename, command_line_args,
2593                                    num_command_line_args, unsaved_files,
2594                                    num_unsaved_files, options, 0 };
2595  llvm::CrashRecoveryContext CRC;
2596
2597  if (!RunSafely(CRC, clang_parseTranslationUnit_Impl, &PTUI)) {
2598    fprintf(stderr, "libclang: crash detected during parsing: {\n");
2599    fprintf(stderr, "  'source_filename' : '%s'\n", source_filename);
2600    fprintf(stderr, "  'command_line_args' : [");
2601    for (int i = 0; i != num_command_line_args; ++i) {
2602      if (i)
2603        fprintf(stderr, ", ");
2604      fprintf(stderr, "'%s'", command_line_args[i]);
2605    }
2606    fprintf(stderr, "],\n");
2607    fprintf(stderr, "  'unsaved_files' : [");
2608    for (unsigned i = 0; i != num_unsaved_files; ++i) {
2609      if (i)
2610        fprintf(stderr, ", ");
2611      fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename,
2612              unsaved_files[i].Length);
2613    }
2614    fprintf(stderr, "],\n");
2615    fprintf(stderr, "  'options' : %d,\n", options);
2616    fprintf(stderr, "}\n");
2617
2618    return 0;
2619  } else if (getenv("LIBCLANG_RESOURCE_USAGE")) {
2620    PrintLibclangResourceUsage(PTUI.result);
2621  }
2622
2623  return PTUI.result;
2624}
2625
2626unsigned clang_defaultSaveOptions(CXTranslationUnit TU) {
2627  return CXSaveTranslationUnit_None;
2628}
2629
2630int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName,
2631                              unsigned options) {
2632  if (!TU)
2633    return CXSaveError_InvalidTU;
2634
2635  CXSaveError result = static_cast<ASTUnit *>(TU->TUData)->Save(FileName);
2636  if (getenv("LIBCLANG_RESOURCE_USAGE"))
2637    PrintLibclangResourceUsage(TU);
2638  return result;
2639}
2640
2641void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) {
2642  if (CTUnit) {
2643    // If the translation unit has been marked as unsafe to free, just discard
2644    // it.
2645    if (static_cast<ASTUnit *>(CTUnit->TUData)->isUnsafeToFree())
2646      return;
2647
2648    delete static_cast<ASTUnit *>(CTUnit->TUData);
2649    disposeCXStringPool(CTUnit->StringPool);
2650    delete CTUnit;
2651  }
2652}
2653
2654unsigned clang_defaultReparseOptions(CXTranslationUnit TU) {
2655  return CXReparse_None;
2656}
2657
2658struct ReparseTranslationUnitInfo {
2659  CXTranslationUnit TU;
2660  unsigned num_unsaved_files;
2661  struct CXUnsavedFile *unsaved_files;
2662  unsigned options;
2663  int result;
2664};
2665
2666static void clang_reparseTranslationUnit_Impl(void *UserData) {
2667  ReparseTranslationUnitInfo *RTUI =
2668    static_cast<ReparseTranslationUnitInfo*>(UserData);
2669  CXTranslationUnit TU = RTUI->TU;
2670  unsigned num_unsaved_files = RTUI->num_unsaved_files;
2671  struct CXUnsavedFile *unsaved_files = RTUI->unsaved_files;
2672  unsigned options = RTUI->options;
2673  (void) options;
2674  RTUI->result = 1;
2675
2676  if (!TU)
2677    return;
2678
2679  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
2680  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
2681
2682  llvm::OwningPtr<std::vector<ASTUnit::RemappedFile> >
2683    RemappedFiles(new std::vector<ASTUnit::RemappedFile>());
2684
2685  // Recover resources if we crash before exiting this function.
2686  llvm::CrashRecoveryContextCleanupRegistrar<
2687    std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
2688
2689  for (unsigned I = 0; I != num_unsaved_files; ++I) {
2690    StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length);
2691    const llvm::MemoryBuffer *Buffer
2692      = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename);
2693    RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename,
2694                                            Buffer));
2695  }
2696
2697  if (!CXXUnit->Reparse(RemappedFiles->size() ? &(*RemappedFiles)[0] : 0,
2698                        RemappedFiles->size()))
2699    RTUI->result = 0;
2700}
2701
2702int clang_reparseTranslationUnit(CXTranslationUnit TU,
2703                                 unsigned num_unsaved_files,
2704                                 struct CXUnsavedFile *unsaved_files,
2705                                 unsigned options) {
2706  ReparseTranslationUnitInfo RTUI = { TU, num_unsaved_files, unsaved_files,
2707                                      options, 0 };
2708  llvm::CrashRecoveryContext CRC;
2709
2710  if (!RunSafely(CRC, clang_reparseTranslationUnit_Impl, &RTUI)) {
2711    fprintf(stderr, "libclang: crash detected during reparsing\n");
2712    static_cast<ASTUnit *>(TU->TUData)->setUnsafeToFree(true);
2713    return 1;
2714  } else if (getenv("LIBCLANG_RESOURCE_USAGE"))
2715    PrintLibclangResourceUsage(TU);
2716
2717  return RTUI.result;
2718}
2719
2720
2721CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) {
2722  if (!CTUnit)
2723    return createCXString("");
2724
2725  ASTUnit *CXXUnit = static_cast<ASTUnit *>(CTUnit->TUData);
2726  return createCXString(CXXUnit->getOriginalSourceFileName(), true);
2727}
2728
2729CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) {
2730  CXCursor Result = { CXCursor_TranslationUnit, { 0, 0, TU } };
2731  return Result;
2732}
2733
2734} // end: extern "C"
2735
2736//===----------------------------------------------------------------------===//
2737// CXSourceLocation and CXSourceRange Operations.
2738//===----------------------------------------------------------------------===//
2739
2740extern "C" {
2741CXSourceLocation clang_getNullLocation() {
2742  CXSourceLocation Result = { { 0, 0 }, 0 };
2743  return Result;
2744}
2745
2746unsigned clang_equalLocations(CXSourceLocation loc1, CXSourceLocation loc2) {
2747  return (loc1.ptr_data[0] == loc2.ptr_data[0] &&
2748          loc1.ptr_data[1] == loc2.ptr_data[1] &&
2749          loc1.int_data == loc2.int_data);
2750}
2751
2752CXSourceLocation clang_getLocation(CXTranslationUnit tu,
2753                                   CXFile file,
2754                                   unsigned line,
2755                                   unsigned column) {
2756  if (!tu || !file)
2757    return clang_getNullLocation();
2758
2759  bool Logging = ::getenv("LIBCLANG_LOGGING");
2760  ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData);
2761  const FileEntry *File = static_cast<const FileEntry *>(file);
2762  SourceLocation SLoc
2763    = CXXUnit->getSourceManager().getLocation(File, line, column);
2764  if (SLoc.isInvalid()) {
2765    if (Logging)
2766      llvm::errs() << "clang_getLocation(\"" << File->getName()
2767                   << "\", " << line << ", " << column << ") = invalid\n";
2768    return clang_getNullLocation();
2769  }
2770
2771  if (Logging)
2772    llvm::errs() << "clang_getLocation(\"" << File->getName()
2773                 << "\", " << line << ", " << column << ") = "
2774                 << SLoc.getRawEncoding() << "\n";
2775
2776  return cxloc::translateSourceLocation(CXXUnit->getASTContext(), SLoc);
2777}
2778
2779CXSourceLocation clang_getLocationForOffset(CXTranslationUnit tu,
2780                                            CXFile file,
2781                                            unsigned offset) {
2782  if (!tu || !file)
2783    return clang_getNullLocation();
2784
2785  ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData);
2786  SourceLocation Start
2787    = CXXUnit->getSourceManager().getLocation(
2788                                        static_cast<const FileEntry *>(file),
2789                                              1, 1);
2790  if (Start.isInvalid()) return clang_getNullLocation();
2791
2792  SourceLocation SLoc = Start.getFileLocWithOffset(offset);
2793
2794  if (SLoc.isInvalid()) return clang_getNullLocation();
2795
2796  return cxloc::translateSourceLocation(CXXUnit->getASTContext(), SLoc);
2797}
2798
2799CXSourceRange clang_getNullRange() {
2800  CXSourceRange Result = { { 0, 0 }, 0, 0 };
2801  return Result;
2802}
2803
2804CXSourceRange clang_getRange(CXSourceLocation begin, CXSourceLocation end) {
2805  if (begin.ptr_data[0] != end.ptr_data[0] ||
2806      begin.ptr_data[1] != end.ptr_data[1])
2807    return clang_getNullRange();
2808
2809  CXSourceRange Result = { { begin.ptr_data[0], begin.ptr_data[1] },
2810                           begin.int_data, end.int_data };
2811  return Result;
2812}
2813
2814unsigned clang_equalRanges(CXSourceRange range1, CXSourceRange range2)
2815{
2816  return range1.ptr_data[0] == range2.ptr_data[0]
2817      && range1.ptr_data[1] == range2.ptr_data[1]
2818      && range1.begin_int_data == range2.begin_int_data
2819      && range1.end_int_data == range2.end_int_data;
2820}
2821} // end: extern "C"
2822
2823static void createNullLocation(CXFile *file, unsigned *line,
2824                               unsigned *column, unsigned *offset) {
2825  if (file)
2826   *file = 0;
2827  if (line)
2828   *line = 0;
2829  if (column)
2830   *column = 0;
2831  if (offset)
2832   *offset = 0;
2833  return;
2834}
2835
2836extern "C" {
2837void clang_getInstantiationLocation(CXSourceLocation location,
2838                                    CXFile *file,
2839                                    unsigned *line,
2840                                    unsigned *column,
2841                                    unsigned *offset) {
2842  SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
2843
2844  if (!location.ptr_data[0] || Loc.isInvalid()) {
2845    createNullLocation(file, line, column, offset);
2846    return;
2847  }
2848
2849  const SourceManager &SM =
2850    *static_cast<const SourceManager*>(location.ptr_data[0]);
2851  SourceLocation InstLoc = SM.getExpansionLoc(Loc);
2852
2853  // Check that the FileID is invalid on the expansion location.
2854  // This can manifest in invalid code.
2855  FileID fileID = SM.getFileID(InstLoc);
2856  bool Invalid = false;
2857  const SrcMgr::SLocEntry &sloc = SM.getSLocEntry(fileID, &Invalid);
2858  if (!sloc.isFile() || Invalid) {
2859    createNullLocation(file, line, column, offset);
2860    return;
2861  }
2862
2863  if (file)
2864    *file = (void *)SM.getFileEntryForSLocEntry(sloc);
2865  if (line)
2866    *line = SM.getExpansionLineNumber(InstLoc);
2867  if (column)
2868    *column = SM.getExpansionColumnNumber(InstLoc);
2869  if (offset)
2870    *offset = SM.getDecomposedLoc(InstLoc).second;
2871}
2872
2873void clang_getSpellingLocation(CXSourceLocation location,
2874                               CXFile *file,
2875                               unsigned *line,
2876                               unsigned *column,
2877                               unsigned *offset) {
2878  SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
2879
2880  if (!location.ptr_data[0] || Loc.isInvalid())
2881    return createNullLocation(file, line, column, offset);
2882
2883  const SourceManager &SM =
2884    *static_cast<const SourceManager*>(location.ptr_data[0]);
2885  SourceLocation SpellLoc = Loc;
2886  if (SpellLoc.isMacroID()) {
2887    SourceLocation SimpleSpellingLoc = SM.getImmediateSpellingLoc(SpellLoc);
2888    if (SimpleSpellingLoc.isFileID() &&
2889        SM.getFileEntryForID(SM.getDecomposedLoc(SimpleSpellingLoc).first))
2890      SpellLoc = SimpleSpellingLoc;
2891    else
2892      SpellLoc = SM.getExpansionLoc(SpellLoc);
2893  }
2894
2895  std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(SpellLoc);
2896  FileID FID = LocInfo.first;
2897  unsigned FileOffset = LocInfo.second;
2898
2899  if (FID.isInvalid())
2900    return createNullLocation(file, line, column, offset);
2901
2902  if (file)
2903    *file = (void *)SM.getFileEntryForID(FID);
2904  if (line)
2905    *line = SM.getLineNumber(FID, FileOffset);
2906  if (column)
2907    *column = SM.getColumnNumber(FID, FileOffset);
2908  if (offset)
2909    *offset = FileOffset;
2910}
2911
2912CXSourceLocation clang_getRangeStart(CXSourceRange range) {
2913  CXSourceLocation Result = { { range.ptr_data[0], range.ptr_data[1] },
2914                              range.begin_int_data };
2915  return Result;
2916}
2917
2918CXSourceLocation clang_getRangeEnd(CXSourceRange range) {
2919  CXSourceLocation Result = { { range.ptr_data[0], range.ptr_data[1] },
2920                              range.end_int_data };
2921  return Result;
2922}
2923
2924} // end: extern "C"
2925
2926//===----------------------------------------------------------------------===//
2927// CXFile Operations.
2928//===----------------------------------------------------------------------===//
2929
2930extern "C" {
2931CXString clang_getFileName(CXFile SFile) {
2932  if (!SFile)
2933    return createCXString((const char*)NULL);
2934
2935  FileEntry *FEnt = static_cast<FileEntry *>(SFile);
2936  return createCXString(FEnt->getName());
2937}
2938
2939time_t clang_getFileTime(CXFile SFile) {
2940  if (!SFile)
2941    return 0;
2942
2943  FileEntry *FEnt = static_cast<FileEntry *>(SFile);
2944  return FEnt->getModificationTime();
2945}
2946
2947CXFile clang_getFile(CXTranslationUnit tu, const char *file_name) {
2948  if (!tu)
2949    return 0;
2950
2951  ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData);
2952
2953  FileManager &FMgr = CXXUnit->getFileManager();
2954  return const_cast<FileEntry *>(FMgr.getFile(file_name));
2955}
2956
2957unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit tu, CXFile file) {
2958  if (!tu || !file)
2959    return 0;
2960
2961  ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData);
2962  FileEntry *FEnt = static_cast<FileEntry *>(file);
2963  return CXXUnit->getPreprocessor().getHeaderSearchInfo()
2964                                          .isFileMultipleIncludeGuarded(FEnt);
2965}
2966
2967} // end: extern "C"
2968
2969//===----------------------------------------------------------------------===//
2970// CXCursor Operations.
2971//===----------------------------------------------------------------------===//
2972
2973static Decl *getDeclFromExpr(Stmt *E) {
2974  if (CastExpr *CE = dyn_cast<CastExpr>(E))
2975    return getDeclFromExpr(CE->getSubExpr());
2976
2977  if (DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E))
2978    return RefExpr->getDecl();
2979  if (BlockDeclRefExpr *RefExpr = dyn_cast<BlockDeclRefExpr>(E))
2980    return RefExpr->getDecl();
2981  if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
2982    return ME->getMemberDecl();
2983  if (ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E))
2984    return RE->getDecl();
2985  if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E))
2986    return PRE->isExplicitProperty() ? PRE->getExplicitProperty() : 0;
2987
2988  if (CallExpr *CE = dyn_cast<CallExpr>(E))
2989    return getDeclFromExpr(CE->getCallee());
2990  if (CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E))
2991    if (!CE->isElidable())
2992    return CE->getConstructor();
2993  if (ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E))
2994    return OME->getMethodDecl();
2995
2996  if (ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E))
2997    return PE->getProtocol();
2998  if (SubstNonTypeTemplateParmPackExpr *NTTP
2999                              = dyn_cast<SubstNonTypeTemplateParmPackExpr>(E))
3000    return NTTP->getParameterPack();
3001  if (SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
3002    if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) ||
3003        isa<ParmVarDecl>(SizeOfPack->getPack()))
3004      return SizeOfPack->getPack();
3005
3006  return 0;
3007}
3008
3009static SourceLocation getLocationFromExpr(Expr *E) {
3010  if (ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E))
3011    return /*FIXME:*/Msg->getLeftLoc();
3012  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
3013    return DRE->getLocation();
3014  if (BlockDeclRefExpr *RefExpr = dyn_cast<BlockDeclRefExpr>(E))
3015    return RefExpr->getLocation();
3016  if (MemberExpr *Member = dyn_cast<MemberExpr>(E))
3017    return Member->getMemberLoc();
3018  if (ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E))
3019    return Ivar->getLocation();
3020  if (SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
3021    return SizeOfPack->getPackLoc();
3022
3023  return E->getLocStart();
3024}
3025
3026extern "C" {
3027
3028unsigned clang_visitChildren(CXCursor parent,
3029                             CXCursorVisitor visitor,
3030                             CXClientData client_data) {
3031  CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data,
3032                          getCursorASTUnit(parent)->getMaxPCHLevel(),
3033                          false);
3034  return CursorVis.VisitChildren(parent);
3035}
3036
3037#ifndef __has_feature
3038#define __has_feature(x) 0
3039#endif
3040#if __has_feature(blocks)
3041typedef enum CXChildVisitResult
3042     (^CXCursorVisitorBlock)(CXCursor cursor, CXCursor parent);
3043
3044static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
3045    CXClientData client_data) {
3046  CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
3047  return block(cursor, parent);
3048}
3049#else
3050// If we are compiled with a compiler that doesn't have native blocks support,
3051// define and call the block manually, so the
3052typedef struct _CXChildVisitResult
3053{
3054	void *isa;
3055	int flags;
3056	int reserved;
3057	enum CXChildVisitResult(*invoke)(struct _CXChildVisitResult*, CXCursor,
3058                                         CXCursor);
3059} *CXCursorVisitorBlock;
3060
3061static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
3062    CXClientData client_data) {
3063  CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
3064  return block->invoke(block, cursor, parent);
3065}
3066#endif
3067
3068
3069unsigned clang_visitChildrenWithBlock(CXCursor parent,
3070                                      CXCursorVisitorBlock block) {
3071  return clang_visitChildren(parent, visitWithBlock, block);
3072}
3073
3074static CXString getDeclSpelling(Decl *D) {
3075  NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D);
3076  if (!ND) {
3077    if (ObjCPropertyImplDecl *PropImpl =dyn_cast<ObjCPropertyImplDecl>(D))
3078      if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
3079        return createCXString(Property->getIdentifier()->getName());
3080
3081    return createCXString("");
3082  }
3083
3084  if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
3085    return createCXString(OMD->getSelector().getAsString());
3086
3087  if (ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND))
3088    // No, this isn't the same as the code below. getIdentifier() is non-virtual
3089    // and returns different names. NamedDecl returns the class name and
3090    // ObjCCategoryImplDecl returns the category name.
3091    return createCXString(CIMP->getIdentifier()->getNameStart());
3092
3093  if (isa<UsingDirectiveDecl>(D))
3094    return createCXString("");
3095
3096  llvm::SmallString<1024> S;
3097  llvm::raw_svector_ostream os(S);
3098  ND->printName(os);
3099
3100  return createCXString(os.str());
3101}
3102
3103CXString clang_getCursorSpelling(CXCursor C) {
3104  if (clang_isTranslationUnit(C.kind))
3105    return clang_getTranslationUnitSpelling(
3106                            static_cast<CXTranslationUnit>(C.data[2]));
3107
3108  if (clang_isReference(C.kind)) {
3109    switch (C.kind) {
3110    case CXCursor_ObjCSuperClassRef: {
3111      ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first;
3112      return createCXString(Super->getIdentifier()->getNameStart());
3113    }
3114    case CXCursor_ObjCClassRef: {
3115      ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
3116      return createCXString(Class->getIdentifier()->getNameStart());
3117    }
3118    case CXCursor_ObjCProtocolRef: {
3119      ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first;
3120      assert(OID && "getCursorSpelling(): Missing protocol decl");
3121      return createCXString(OID->getIdentifier()->getNameStart());
3122    }
3123    case CXCursor_CXXBaseSpecifier: {
3124      CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C);
3125      return createCXString(B->getType().getAsString());
3126    }
3127    case CXCursor_TypeRef: {
3128      TypeDecl *Type = getCursorTypeRef(C).first;
3129      assert(Type && "Missing type decl");
3130
3131      return createCXString(getCursorContext(C).getTypeDeclType(Type).
3132                              getAsString());
3133    }
3134    case CXCursor_TemplateRef: {
3135      TemplateDecl *Template = getCursorTemplateRef(C).first;
3136      assert(Template && "Missing template decl");
3137
3138      return createCXString(Template->getNameAsString());
3139    }
3140
3141    case CXCursor_NamespaceRef: {
3142      NamedDecl *NS = getCursorNamespaceRef(C).first;
3143      assert(NS && "Missing namespace decl");
3144
3145      return createCXString(NS->getNameAsString());
3146    }
3147
3148    case CXCursor_MemberRef: {
3149      FieldDecl *Field = getCursorMemberRef(C).first;
3150      assert(Field && "Missing member decl");
3151
3152      return createCXString(Field->getNameAsString());
3153    }
3154
3155    case CXCursor_LabelRef: {
3156      LabelStmt *Label = getCursorLabelRef(C).first;
3157      assert(Label && "Missing label");
3158
3159      return createCXString(Label->getName());
3160    }
3161
3162    case CXCursor_OverloadedDeclRef: {
3163      OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
3164      if (Decl *D = Storage.dyn_cast<Decl *>()) {
3165        if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
3166          return createCXString(ND->getNameAsString());
3167        return createCXString("");
3168      }
3169      if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>())
3170        return createCXString(E->getName().getAsString());
3171      OverloadedTemplateStorage *Ovl
3172        = Storage.get<OverloadedTemplateStorage*>();
3173      if (Ovl->size() == 0)
3174        return createCXString("");
3175      return createCXString((*Ovl->begin())->getNameAsString());
3176    }
3177
3178    default:
3179      return createCXString("<not implemented>");
3180    }
3181  }
3182
3183  if (clang_isExpression(C.kind)) {
3184    Decl *D = getDeclFromExpr(getCursorExpr(C));
3185    if (D)
3186      return getDeclSpelling(D);
3187    return createCXString("");
3188  }
3189
3190  if (clang_isStatement(C.kind)) {
3191    Stmt *S = getCursorStmt(C);
3192    if (LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
3193      return createCXString(Label->getName());
3194
3195    return createCXString("");
3196  }
3197
3198  if (C.kind == CXCursor_MacroExpansion)
3199    return createCXString(getCursorMacroExpansion(C)->getName()
3200                                                           ->getNameStart());
3201
3202  if (C.kind == CXCursor_MacroDefinition)
3203    return createCXString(getCursorMacroDefinition(C)->getName()
3204                                                           ->getNameStart());
3205
3206  if (C.kind == CXCursor_InclusionDirective)
3207    return createCXString(getCursorInclusionDirective(C)->getFileName());
3208
3209  if (clang_isDeclaration(C.kind))
3210    return getDeclSpelling(getCursorDecl(C));
3211
3212  return createCXString("");
3213}
3214
3215CXString clang_getCursorDisplayName(CXCursor C) {
3216  if (!clang_isDeclaration(C.kind))
3217    return clang_getCursorSpelling(C);
3218
3219  Decl *D = getCursorDecl(C);
3220  if (!D)
3221    return createCXString("");
3222
3223  PrintingPolicy &Policy = getCursorContext(C).PrintingPolicy;
3224  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
3225    D = FunTmpl->getTemplatedDecl();
3226
3227  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
3228    llvm::SmallString<64> Str;
3229    llvm::raw_svector_ostream OS(Str);
3230    OS << Function->getNameAsString();
3231    if (Function->getPrimaryTemplate())
3232      OS << "<>";
3233    OS << "(";
3234    for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) {
3235      if (I)
3236        OS << ", ";
3237      OS << Function->getParamDecl(I)->getType().getAsString(Policy);
3238    }
3239
3240    if (Function->isVariadic()) {
3241      if (Function->getNumParams())
3242        OS << ", ";
3243      OS << "...";
3244    }
3245    OS << ")";
3246    return createCXString(OS.str());
3247  }
3248
3249  if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) {
3250    llvm::SmallString<64> Str;
3251    llvm::raw_svector_ostream OS(Str);
3252    OS << ClassTemplate->getNameAsString();
3253    OS << "<";
3254    TemplateParameterList *Params = ClassTemplate->getTemplateParameters();
3255    for (unsigned I = 0, N = Params->size(); I != N; ++I) {
3256      if (I)
3257        OS << ", ";
3258
3259      NamedDecl *Param = Params->getParam(I);
3260      if (Param->getIdentifier()) {
3261        OS << Param->getIdentifier()->getName();
3262        continue;
3263      }
3264
3265      // There is no parameter name, which makes this tricky. Try to come up
3266      // with something useful that isn't too long.
3267      if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
3268        OS << (TTP->wasDeclaredWithTypename()? "typename" : "class");
3269      else if (NonTypeTemplateParmDecl *NTTP
3270                                    = dyn_cast<NonTypeTemplateParmDecl>(Param))
3271        OS << NTTP->getType().getAsString(Policy);
3272      else
3273        OS << "template<...> class";
3274    }
3275
3276    OS << ">";
3277    return createCXString(OS.str());
3278  }
3279
3280  if (ClassTemplateSpecializationDecl *ClassSpec
3281                              = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
3282    // If the type was explicitly written, use that.
3283    if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten())
3284      return createCXString(TSInfo->getType().getAsString(Policy));
3285
3286    llvm::SmallString<64> Str;
3287    llvm::raw_svector_ostream OS(Str);
3288    OS << ClassSpec->getNameAsString();
3289    OS << TemplateSpecializationType::PrintTemplateArgumentList(
3290                                      ClassSpec->getTemplateArgs().data(),
3291                                      ClassSpec->getTemplateArgs().size(),
3292                                                                Policy);
3293    return createCXString(OS.str());
3294  }
3295
3296  return clang_getCursorSpelling(C);
3297}
3298
3299CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
3300  switch (Kind) {
3301  case CXCursor_FunctionDecl:
3302      return createCXString("FunctionDecl");
3303  case CXCursor_TypedefDecl:
3304      return createCXString("TypedefDecl");
3305  case CXCursor_EnumDecl:
3306      return createCXString("EnumDecl");
3307  case CXCursor_EnumConstantDecl:
3308      return createCXString("EnumConstantDecl");
3309  case CXCursor_StructDecl:
3310      return createCXString("StructDecl");
3311  case CXCursor_UnionDecl:
3312      return createCXString("UnionDecl");
3313  case CXCursor_ClassDecl:
3314      return createCXString("ClassDecl");
3315  case CXCursor_FieldDecl:
3316      return createCXString("FieldDecl");
3317  case CXCursor_VarDecl:
3318      return createCXString("VarDecl");
3319  case CXCursor_ParmDecl:
3320      return createCXString("ParmDecl");
3321  case CXCursor_ObjCInterfaceDecl:
3322      return createCXString("ObjCInterfaceDecl");
3323  case CXCursor_ObjCCategoryDecl:
3324      return createCXString("ObjCCategoryDecl");
3325  case CXCursor_ObjCProtocolDecl:
3326      return createCXString("ObjCProtocolDecl");
3327  case CXCursor_ObjCPropertyDecl:
3328      return createCXString("ObjCPropertyDecl");
3329  case CXCursor_ObjCIvarDecl:
3330      return createCXString("ObjCIvarDecl");
3331  case CXCursor_ObjCInstanceMethodDecl:
3332      return createCXString("ObjCInstanceMethodDecl");
3333  case CXCursor_ObjCClassMethodDecl:
3334      return createCXString("ObjCClassMethodDecl");
3335  case CXCursor_ObjCImplementationDecl:
3336      return createCXString("ObjCImplementationDecl");
3337  case CXCursor_ObjCCategoryImplDecl:
3338      return createCXString("ObjCCategoryImplDecl");
3339  case CXCursor_CXXMethod:
3340      return createCXString("CXXMethod");
3341  case CXCursor_UnexposedDecl:
3342      return createCXString("UnexposedDecl");
3343  case CXCursor_ObjCSuperClassRef:
3344      return createCXString("ObjCSuperClassRef");
3345  case CXCursor_ObjCProtocolRef:
3346      return createCXString("ObjCProtocolRef");
3347  case CXCursor_ObjCClassRef:
3348      return createCXString("ObjCClassRef");
3349  case CXCursor_TypeRef:
3350      return createCXString("TypeRef");
3351  case CXCursor_TemplateRef:
3352      return createCXString("TemplateRef");
3353  case CXCursor_NamespaceRef:
3354    return createCXString("NamespaceRef");
3355  case CXCursor_MemberRef:
3356    return createCXString("MemberRef");
3357  case CXCursor_LabelRef:
3358    return createCXString("LabelRef");
3359  case CXCursor_OverloadedDeclRef:
3360    return createCXString("OverloadedDeclRef");
3361  case CXCursor_UnexposedExpr:
3362      return createCXString("UnexposedExpr");
3363  case CXCursor_BlockExpr:
3364      return createCXString("BlockExpr");
3365  case CXCursor_DeclRefExpr:
3366      return createCXString("DeclRefExpr");
3367  case CXCursor_MemberRefExpr:
3368      return createCXString("MemberRefExpr");
3369  case CXCursor_CallExpr:
3370      return createCXString("CallExpr");
3371  case CXCursor_ObjCMessageExpr:
3372      return createCXString("ObjCMessageExpr");
3373  case CXCursor_UnexposedStmt:
3374      return createCXString("UnexposedStmt");
3375  case CXCursor_LabelStmt:
3376      return createCXString("LabelStmt");
3377  case CXCursor_InvalidFile:
3378      return createCXString("InvalidFile");
3379  case CXCursor_InvalidCode:
3380    return createCXString("InvalidCode");
3381  case CXCursor_NoDeclFound:
3382      return createCXString("NoDeclFound");
3383  case CXCursor_NotImplemented:
3384      return createCXString("NotImplemented");
3385  case CXCursor_TranslationUnit:
3386      return createCXString("TranslationUnit");
3387  case CXCursor_UnexposedAttr:
3388      return createCXString("UnexposedAttr");
3389  case CXCursor_IBActionAttr:
3390      return createCXString("attribute(ibaction)");
3391  case CXCursor_IBOutletAttr:
3392     return createCXString("attribute(iboutlet)");
3393  case CXCursor_IBOutletCollectionAttr:
3394      return createCXString("attribute(iboutletcollection)");
3395  case CXCursor_PreprocessingDirective:
3396    return createCXString("preprocessing directive");
3397  case CXCursor_MacroDefinition:
3398    return createCXString("macro definition");
3399  case CXCursor_MacroExpansion:
3400    return createCXString("macro expansion");
3401  case CXCursor_InclusionDirective:
3402    return createCXString("inclusion directive");
3403  case CXCursor_Namespace:
3404    return createCXString("Namespace");
3405  case CXCursor_LinkageSpec:
3406    return createCXString("LinkageSpec");
3407  case CXCursor_CXXBaseSpecifier:
3408    return createCXString("C++ base class specifier");
3409  case CXCursor_Constructor:
3410    return createCXString("CXXConstructor");
3411  case CXCursor_Destructor:
3412    return createCXString("CXXDestructor");
3413  case CXCursor_ConversionFunction:
3414    return createCXString("CXXConversion");
3415  case CXCursor_TemplateTypeParameter:
3416    return createCXString("TemplateTypeParameter");
3417  case CXCursor_NonTypeTemplateParameter:
3418    return createCXString("NonTypeTemplateParameter");
3419  case CXCursor_TemplateTemplateParameter:
3420    return createCXString("TemplateTemplateParameter");
3421  case CXCursor_FunctionTemplate:
3422    return createCXString("FunctionTemplate");
3423  case CXCursor_ClassTemplate:
3424    return createCXString("ClassTemplate");
3425  case CXCursor_ClassTemplatePartialSpecialization:
3426    return createCXString("ClassTemplatePartialSpecialization");
3427  case CXCursor_NamespaceAlias:
3428    return createCXString("NamespaceAlias");
3429  case CXCursor_UsingDirective:
3430    return createCXString("UsingDirective");
3431  case CXCursor_UsingDeclaration:
3432    return createCXString("UsingDeclaration");
3433  case CXCursor_TypeAliasDecl:
3434    return createCXString("TypeAliasDecl");
3435  case CXCursor_ObjCSynthesizeDecl:
3436    return createCXString("ObjCSynthesizeDecl");
3437  case CXCursor_ObjCDynamicDecl:
3438    return createCXString("ObjCDynamicDecl");
3439  }
3440
3441  llvm_unreachable("Unhandled CXCursorKind");
3442  return createCXString((const char*) 0);
3443}
3444
3445struct GetCursorData {
3446  SourceLocation TokenBeginLoc;
3447  bool PointsAtMacroArgExpansion;
3448  CXCursor &BestCursor;
3449
3450  GetCursorData(SourceManager &SM,
3451                SourceLocation tokenBegin, CXCursor &outputCursor)
3452    : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) {
3453    PointsAtMacroArgExpansion = SM.isMacroArgExpansion(tokenBegin);
3454  }
3455};
3456
3457static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor,
3458                                                CXCursor parent,
3459                                                CXClientData client_data) {
3460  GetCursorData *Data = static_cast<GetCursorData *>(client_data);
3461  CXCursor *BestCursor = &Data->BestCursor;
3462
3463  // If we point inside a macro argument we should provide info of what the
3464  // token is so use the actual cursor, don't replace it with a macro expansion
3465  // cursor.
3466  if (cursor.kind == CXCursor_MacroExpansion && Data->PointsAtMacroArgExpansion)
3467    return CXChildVisit_Recurse;
3468
3469  if (clang_isExpression(cursor.kind) &&
3470      clang_isDeclaration(BestCursor->kind)) {
3471    Decl *D = getCursorDecl(*BestCursor);
3472
3473    // Avoid having the cursor of an expression replace the declaration cursor
3474    // when the expression source range overlaps the declaration range.
3475    // This can happen for C++ constructor expressions whose range generally
3476    // include the variable declaration, e.g.:
3477    //  MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl cursor.
3478    if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() &&
3479        D->getLocation() == Data->TokenBeginLoc)
3480      return CXChildVisit_Break;
3481  }
3482
3483  // If our current best cursor is the construction of a temporary object,
3484  // don't replace that cursor with a type reference, because we want
3485  // clang_getCursor() to point at the constructor.
3486  if (clang_isExpression(BestCursor->kind) &&
3487      isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) &&
3488      cursor.kind == CXCursor_TypeRef)
3489    return CXChildVisit_Recurse;
3490
3491  // Don't override a preprocessing cursor with another preprocessing
3492  // cursor; we want the outermost preprocessing cursor.
3493  if (clang_isPreprocessing(cursor.kind) &&
3494      clang_isPreprocessing(BestCursor->kind))
3495    return CXChildVisit_Recurse;
3496
3497  *BestCursor = cursor;
3498  return CXChildVisit_Recurse;
3499}
3500
3501CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) {
3502  if (!TU)
3503    return clang_getNullCursor();
3504
3505  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
3506  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
3507
3508  // Translate the given source location to make it point at the beginning of
3509  // the token under the cursor.
3510  SourceLocation SLoc = cxloc::translateSourceLocation(Loc);
3511
3512  // Guard against an invalid SourceLocation, or we may assert in one
3513  // of the following calls.
3514  if (SLoc.isInvalid())
3515    return clang_getNullCursor();
3516
3517  bool Logging = getenv("LIBCLANG_LOGGING");
3518  SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(),
3519                                    CXXUnit->getASTContext().getLangOptions());
3520
3521  CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound);
3522  if (SLoc.isValid()) {
3523    // FIXME: Would be great to have a "hint" cursor, then walk from that
3524    // hint cursor upward until we find a cursor whose source range encloses
3525    // the region of interest, rather than starting from the translation unit.
3526    GetCursorData ResultData(CXXUnit->getSourceManager(), SLoc, Result);
3527    CXCursor Parent = clang_getTranslationUnitCursor(TU);
3528    CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData,
3529                            Decl::MaxPCHLevel, true, SourceLocation(SLoc));
3530    CursorVis.VisitChildren(Parent);
3531  }
3532
3533  if (Logging) {
3534    CXFile SearchFile;
3535    unsigned SearchLine, SearchColumn;
3536    CXFile ResultFile;
3537    unsigned ResultLine, ResultColumn;
3538    CXString SearchFileName, ResultFileName, KindSpelling, USR;
3539    const char *IsDef = clang_isCursorDefinition(Result)? " (Definition)" : "";
3540    CXSourceLocation ResultLoc = clang_getCursorLocation(Result);
3541
3542    clang_getInstantiationLocation(Loc, &SearchFile, &SearchLine, &SearchColumn,
3543                                   0);
3544    clang_getInstantiationLocation(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_getInstantiationLocation(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 (ObjCClassDecl *Classes = dyn_cast<ObjCClassDecl>(D))
4230    return Classes->size();
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
4261  if (ObjCClassDecl *Classes = dyn_cast<ObjCClassDecl>(D))
4262    return MakeCXCursor(Classes->begin()[index].getInterface(), TU);
4263
4264  if (ObjCForwardProtocolDecl *Protocols = dyn_cast<ObjCForwardProtocolDecl>(D))
4265    return MakeCXCursor(Protocols->protocol_begin()[index], TU);
4266
4267  return clang_getNullCursor();
4268}
4269
4270void clang_getDefinitionSpellingAndExtent(CXCursor C,
4271                                          const char **startBuf,
4272                                          const char **endBuf,
4273                                          unsigned *startLine,
4274                                          unsigned *startColumn,
4275                                          unsigned *endLine,
4276                                          unsigned *endColumn) {
4277  assert(getCursorDecl(C) && "CXCursor has null decl");
4278  NamedDecl *ND = static_cast<NamedDecl *>(getCursorDecl(C));
4279  FunctionDecl *FD = dyn_cast<FunctionDecl>(ND);
4280  CompoundStmt *Body = dyn_cast<CompoundStmt>(FD->getBody());
4281
4282  SourceManager &SM = FD->getASTContext().getSourceManager();
4283  *startBuf = SM.getCharacterData(Body->getLBracLoc());
4284  *endBuf = SM.getCharacterData(Body->getRBracLoc());
4285  *startLine = SM.getSpellingLineNumber(Body->getLBracLoc());
4286  *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc());
4287  *endLine = SM.getSpellingLineNumber(Body->getRBracLoc());
4288  *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc());
4289}
4290
4291
4292CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags,
4293                                                unsigned PieceIndex) {
4294  RefNamePieces Pieces;
4295
4296  switch (C.kind) {
4297  case CXCursor_MemberRefExpr:
4298    if (MemberExpr *E = dyn_cast<MemberExpr>(getCursorExpr(C)))
4299      Pieces = buildPieces(NameFlags, true, E->getMemberNameInfo(),
4300                           E->getQualifierLoc().getSourceRange());
4301    break;
4302
4303  case CXCursor_DeclRefExpr:
4304    if (DeclRefExpr *E = dyn_cast<DeclRefExpr>(getCursorExpr(C)))
4305      Pieces = buildPieces(NameFlags, false, E->getNameInfo(),
4306                           E->getQualifierLoc().getSourceRange(),
4307                           E->getExplicitTemplateArgsOpt());
4308    break;
4309
4310  case CXCursor_CallExpr:
4311    if (CXXOperatorCallExpr *OCE =
4312        dyn_cast<CXXOperatorCallExpr>(getCursorExpr(C))) {
4313      Expr *Callee = OCE->getCallee();
4314      if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee))
4315        Callee = ICE->getSubExpr();
4316
4317      if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee))
4318        Pieces = buildPieces(NameFlags, false, DRE->getNameInfo(),
4319                             DRE->getQualifierLoc().getSourceRange());
4320    }
4321    break;
4322
4323  default:
4324    break;
4325  }
4326
4327  if (Pieces.empty()) {
4328    if (PieceIndex == 0)
4329      return clang_getCursorExtent(C);
4330  } else if (PieceIndex < Pieces.size()) {
4331      SourceRange R = Pieces[PieceIndex];
4332      if (R.isValid())
4333        return cxloc::translateSourceRange(getCursorContext(C), R);
4334  }
4335
4336  return clang_getNullRange();
4337}
4338
4339void clang_enableStackTraces(void) {
4340  llvm::sys::PrintStackTraceOnErrorSignal();
4341}
4342
4343void clang_executeOnThread(void (*fn)(void*), void *user_data,
4344                           unsigned stack_size) {
4345  llvm::llvm_execute_on_thread(fn, user_data, stack_size);
4346}
4347
4348} // end: extern "C"
4349
4350//===----------------------------------------------------------------------===//
4351// Token-based Operations.
4352//===----------------------------------------------------------------------===//
4353
4354/* CXToken layout:
4355 *   int_data[0]: a CXTokenKind
4356 *   int_data[1]: starting token location
4357 *   int_data[2]: token length
4358 *   int_data[3]: reserved
4359 *   ptr_data: for identifiers and keywords, an IdentifierInfo*.
4360 *   otherwise unused.
4361 */
4362extern "C" {
4363
4364CXTokenKind clang_getTokenKind(CXToken CXTok) {
4365  return static_cast<CXTokenKind>(CXTok.int_data[0]);
4366}
4367
4368CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) {
4369  switch (clang_getTokenKind(CXTok)) {
4370  case CXToken_Identifier:
4371  case CXToken_Keyword:
4372    // We know we have an IdentifierInfo*, so use that.
4373    return createCXString(static_cast<IdentifierInfo *>(CXTok.ptr_data)
4374                            ->getNameStart());
4375
4376  case CXToken_Literal: {
4377    // We have stashed the starting pointer in the ptr_data field. Use it.
4378    const char *Text = static_cast<const char *>(CXTok.ptr_data);
4379    return createCXString(StringRef(Text, CXTok.int_data[2]));
4380  }
4381
4382  case CXToken_Punctuation:
4383  case CXToken_Comment:
4384    break;
4385  }
4386
4387  // We have to find the starting buffer pointer the hard way, by
4388  // deconstructing the source location.
4389  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
4390  if (!CXXUnit)
4391    return createCXString("");
4392
4393  SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]);
4394  std::pair<FileID, unsigned> LocInfo
4395    = CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc);
4396  bool Invalid = false;
4397  StringRef Buffer
4398    = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid);
4399  if (Invalid)
4400    return createCXString("");
4401
4402  return createCXString(Buffer.substr(LocInfo.second, CXTok.int_data[2]));
4403}
4404
4405CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) {
4406  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
4407  if (!CXXUnit)
4408    return clang_getNullLocation();
4409
4410  return cxloc::translateSourceLocation(CXXUnit->getASTContext(),
4411                        SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
4412}
4413
4414CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) {
4415  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
4416  if (!CXXUnit)
4417    return clang_getNullRange();
4418
4419  return cxloc::translateSourceRange(CXXUnit->getASTContext(),
4420                        SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
4421}
4422
4423void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range,
4424                    CXToken **Tokens, unsigned *NumTokens) {
4425  if (Tokens)
4426    *Tokens = 0;
4427  if (NumTokens)
4428    *NumTokens = 0;
4429
4430  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
4431  if (!CXXUnit || !Tokens || !NumTokens)
4432    return;
4433
4434  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
4435
4436  SourceRange R = cxloc::translateCXSourceRange(Range);
4437  if (R.isInvalid())
4438    return;
4439
4440  SourceManager &SourceMgr = CXXUnit->getSourceManager();
4441  std::pair<FileID, unsigned> BeginLocInfo
4442    = SourceMgr.getDecomposedLoc(R.getBegin());
4443  std::pair<FileID, unsigned> EndLocInfo
4444    = SourceMgr.getDecomposedLoc(R.getEnd());
4445
4446  // Cannot tokenize across files.
4447  if (BeginLocInfo.first != EndLocInfo.first)
4448    return;
4449
4450  // Create a lexer
4451  bool Invalid = false;
4452  StringRef Buffer
4453    = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
4454  if (Invalid)
4455    return;
4456
4457  Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
4458            CXXUnit->getASTContext().getLangOptions(),
4459            Buffer.begin(), Buffer.data() + BeginLocInfo.second, Buffer.end());
4460  Lex.SetCommentRetentionState(true);
4461
4462  // Lex tokens until we hit the end of the range.
4463  const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second;
4464  SmallVector<CXToken, 32> CXTokens;
4465  Token Tok;
4466  bool previousWasAt = false;
4467  do {
4468    // Lex the next token
4469    Lex.LexFromRawLexer(Tok);
4470    if (Tok.is(tok::eof))
4471      break;
4472
4473    // Initialize the CXToken.
4474    CXToken CXTok;
4475
4476    //   - Common fields
4477    CXTok.int_data[1] = Tok.getLocation().getRawEncoding();
4478    CXTok.int_data[2] = Tok.getLength();
4479    CXTok.int_data[3] = 0;
4480
4481    //   - Kind-specific fields
4482    if (Tok.isLiteral()) {
4483      CXTok.int_data[0] = CXToken_Literal;
4484      CXTok.ptr_data = (void *)Tok.getLiteralData();
4485    } else if (Tok.is(tok::raw_identifier)) {
4486      // Lookup the identifier to determine whether we have a keyword.
4487      IdentifierInfo *II
4488        = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok);
4489
4490      if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) {
4491        CXTok.int_data[0] = CXToken_Keyword;
4492      }
4493      else {
4494        CXTok.int_data[0] = Tok.is(tok::identifier)
4495          ? CXToken_Identifier
4496          : CXToken_Keyword;
4497      }
4498      CXTok.ptr_data = II;
4499    } else if (Tok.is(tok::comment)) {
4500      CXTok.int_data[0] = CXToken_Comment;
4501      CXTok.ptr_data = 0;
4502    } else {
4503      CXTok.int_data[0] = CXToken_Punctuation;
4504      CXTok.ptr_data = 0;
4505    }
4506    CXTokens.push_back(CXTok);
4507    previousWasAt = Tok.is(tok::at);
4508  } while (Lex.getBufferLocation() <= EffectiveBufferEnd);
4509
4510  if (CXTokens.empty())
4511    return;
4512
4513  *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size());
4514  memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size());
4515  *NumTokens = CXTokens.size();
4516}
4517
4518void clang_disposeTokens(CXTranslationUnit TU,
4519                         CXToken *Tokens, unsigned NumTokens) {
4520  free(Tokens);
4521}
4522
4523} // end: extern "C"
4524
4525//===----------------------------------------------------------------------===//
4526// Token annotation APIs.
4527//===----------------------------------------------------------------------===//
4528
4529typedef llvm::DenseMap<unsigned, CXCursor> AnnotateTokensData;
4530static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
4531                                                     CXCursor parent,
4532                                                     CXClientData client_data);
4533namespace {
4534class AnnotateTokensWorker {
4535  AnnotateTokensData &Annotated;
4536  CXToken *Tokens;
4537  CXCursor *Cursors;
4538  unsigned NumTokens;
4539  unsigned TokIdx;
4540  unsigned PreprocessingTokIdx;
4541  CursorVisitor AnnotateVis;
4542  SourceManager &SrcMgr;
4543  bool HasContextSensitiveKeywords;
4544
4545  bool MoreTokens() const { return TokIdx < NumTokens; }
4546  unsigned NextToken() const { return TokIdx; }
4547  void AdvanceToken() { ++TokIdx; }
4548  SourceLocation GetTokenLoc(unsigned tokI) {
4549    return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]);
4550  }
4551  bool isMacroArgToken(unsigned tokI) const {
4552    return Tokens[tokI].int_data[3] != 0;
4553  }
4554  SourceLocation getMacroArgLoc(unsigned tokI) const {
4555    return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[3]);
4556  }
4557
4558  void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange);
4559  void annotateAndAdvanceMacroArgTokens(CXCursor, RangeComparisonResult,
4560                                        SourceRange);
4561
4562public:
4563  AnnotateTokensWorker(AnnotateTokensData &annotated,
4564                       CXToken *tokens, CXCursor *cursors, unsigned numTokens,
4565                       CXTranslationUnit tu, SourceRange RegionOfInterest)
4566    : Annotated(annotated), Tokens(tokens), Cursors(cursors),
4567      NumTokens(numTokens), TokIdx(0), PreprocessingTokIdx(0),
4568      AnnotateVis(tu,
4569                  AnnotateTokensVisitor, this,
4570                  Decl::MaxPCHLevel, true, RegionOfInterest),
4571      SrcMgr(static_cast<ASTUnit*>(tu->TUData)->getSourceManager()),
4572      HasContextSensitiveKeywords(false) { }
4573
4574  void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); }
4575  enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent);
4576  void AnnotateTokens(CXCursor parent);
4577  void AnnotateTokens() {
4578    AnnotateTokens(clang_getTranslationUnitCursor(AnnotateVis.getTU()));
4579  }
4580
4581  /// \brief Determine whether the annotator saw any cursors that have
4582  /// context-sensitive keywords.
4583  bool hasContextSensitiveKeywords() const {
4584    return HasContextSensitiveKeywords;
4585  }
4586};
4587}
4588
4589void AnnotateTokensWorker::AnnotateTokens(CXCursor parent) {
4590  // Walk the AST within the region of interest, annotating tokens
4591  // along the way.
4592  VisitChildren(parent);
4593
4594  for (unsigned I = 0 ; I < TokIdx ; ++I) {
4595    AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]);
4596    if (Pos != Annotated.end() &&
4597        (clang_isInvalid(Cursors[I].kind) ||
4598         Pos->second.kind != CXCursor_PreprocessingDirective))
4599      Cursors[I] = Pos->second;
4600  }
4601
4602  // Finish up annotating any tokens left.
4603  if (!MoreTokens())
4604    return;
4605
4606  const CXCursor &C = clang_getNullCursor();
4607  for (unsigned I = TokIdx ; I < NumTokens ; ++I) {
4608    AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]);
4609    Cursors[I] = (Pos == Annotated.end()) ? C : Pos->second;
4610  }
4611}
4612
4613/// \brief It annotates and advances tokens with a cursor until the comparison
4614//// between the cursor location and the source range is the same as
4615/// \arg compResult.
4616///
4617/// Pass RangeBefore to annotate tokens with a cursor until a range is reached.
4618/// Pass RangeOverlap to annotate tokens inside a range.
4619void AnnotateTokensWorker::annotateAndAdvanceTokens(CXCursor updateC,
4620                                               RangeComparisonResult compResult,
4621                                               SourceRange range) {
4622  while (MoreTokens()) {
4623    const unsigned I = NextToken();
4624    if (isMacroArgToken(I))
4625      return annotateAndAdvanceMacroArgTokens(updateC, compResult, range);
4626
4627    SourceLocation TokLoc = GetTokenLoc(I);
4628    if (LocationCompare(SrcMgr, TokLoc, range) == compResult) {
4629      Cursors[I] = updateC;
4630      AdvanceToken();
4631      continue;
4632    }
4633    break;
4634  }
4635}
4636
4637/// \brief Special annotation handling for macro argument tokens.
4638void AnnotateTokensWorker::annotateAndAdvanceMacroArgTokens(CXCursor updateC,
4639                                               RangeComparisonResult compResult,
4640                                               SourceRange range) {
4641  assert(isMacroArgToken(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 (; isMacroArgToken(I); ++I) {
4656    SourceLocation TokLoc = getMacroArgLoc(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      setMacroArgExpandedLoc(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 setMacroArgExpandedLoc(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