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