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