CIndex.cpp revision a67e03fdf1ae8a1f92463a307d0b6281f1161f40 
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 "CXType.h"
18#include "CXSourceLocation.h"
19#include "CIndexDiagnostic.h"
20
21#include "clang/Basic/Version.h"
22
23#include "clang/AST/DeclVisitor.h"
24#include "clang/AST/StmtVisitor.h"
25#include "clang/AST/TypeLocVisitor.h"
26#include "clang/Basic/Diagnostic.h"
27#include "clang/Frontend/ASTUnit.h"
28#include "clang/Frontend/CompilerInstance.h"
29#include "clang/Frontend/FrontendDiagnostic.h"
30#include "clang/Lex/Lexer.h"
31#include "clang/Lex/PreprocessingRecord.h"
32#include "clang/Lex/Preprocessor.h"
33#include "llvm/ADT/STLExtras.h"
34#include "llvm/Support/CrashRecoveryContext.h"
35#include "llvm/Support/MemoryBuffer.h"
36#include "llvm/Support/Timer.h"
37#include "llvm/System/Program.h"
38#include "llvm/System/Signals.h"
39
40// Needed to define L_TMPNAM on some systems.
41#include <cstdio>
42
43using namespace clang;
44using namespace clang::cxcursor;
45using namespace clang::cxstring;
46
47//===----------------------------------------------------------------------===//
48// Crash Reporting.
49//===----------------------------------------------------------------------===//
50
51#ifdef USE_CRASHTRACER
52#include "clang/Analysis/Support/SaveAndRestore.h"
53// Integrate with crash reporter.
54static const char *__crashreporter_info__ = 0;
55asm(".desc ___crashreporter_info__, 0x10");
56#define NUM_CRASH_STRINGS 32
57static unsigned crashtracer_counter = 0;
58static unsigned crashtracer_counter_id[NUM_CRASH_STRINGS] = { 0 };
59static const char *crashtracer_strings[NUM_CRASH_STRINGS] = { 0 };
60static const char *agg_crashtracer_strings[NUM_CRASH_STRINGS] = { 0 };
61
62static unsigned SetCrashTracerInfo(const char *str,
63                                   llvm::SmallString<1024> &AggStr) {
64
65  unsigned slot = 0;
66  while (crashtracer_strings[slot]) {
67    if (++slot == NUM_CRASH_STRINGS)
68      slot = 0;
69  }
70  crashtracer_strings[slot] = str;
71  crashtracer_counter_id[slot] = ++crashtracer_counter;
72
73  // We need to create an aggregate string because multiple threads
74  // may be in this method at one time.  The crash reporter string
75  // will attempt to overapproximate the set of in-flight invocations
76  // of this function.  Race conditions can still cause this goal
77  // to not be achieved.
78  {
79    llvm::raw_svector_ostream Out(AggStr);
80    for (unsigned i = 0; i < NUM_CRASH_STRINGS; ++i)
81      if (crashtracer_strings[i]) Out << crashtracer_strings[i] << '\n';
82  }
83  __crashreporter_info__ = agg_crashtracer_strings[slot] =  AggStr.c_str();
84  return slot;
85}
86
87static void ResetCrashTracerInfo(unsigned slot) {
88  unsigned max_slot = 0;
89  unsigned max_value = 0;
90
91  crashtracer_strings[slot] = agg_crashtracer_strings[slot] = 0;
92
93  for (unsigned i = 0 ; i < NUM_CRASH_STRINGS; ++i)
94    if (agg_crashtracer_strings[i] &&
95        crashtracer_counter_id[i] > max_value) {
96      max_slot = i;
97      max_value = crashtracer_counter_id[i];
98    }
99
100  __crashreporter_info__ = agg_crashtracer_strings[max_slot];
101}
102
103namespace {
104class ArgsCrashTracerInfo {
105  llvm::SmallString<1024> CrashString;
106  llvm::SmallString<1024> AggregateString;
107  unsigned crashtracerSlot;
108public:
109  ArgsCrashTracerInfo(llvm::SmallVectorImpl<const char*> &Args)
110    : crashtracerSlot(0)
111  {
112    {
113      llvm::raw_svector_ostream Out(CrashString);
114      Out << "ClangCIndex [" << getClangFullVersion() << "]"
115          << "[createTranslationUnitFromSourceFile]: clang";
116      for (llvm::SmallVectorImpl<const char*>::iterator I=Args.begin(),
117           E=Args.end(); I!=E; ++I)
118        Out << ' ' << *I;
119    }
120    crashtracerSlot = SetCrashTracerInfo(CrashString.c_str(),
121                                         AggregateString);
122  }
123
124  ~ArgsCrashTracerInfo() {
125    ResetCrashTracerInfo(crashtracerSlot);
126  }
127};
128}
129#endif
130
131/// \brief The result of comparing two source ranges.
132enum RangeComparisonResult {
133  /// \brief Either the ranges overlap or one of the ranges is invalid.
134  RangeOverlap,
135
136  /// \brief The first range ends before the second range starts.
137  RangeBefore,
138
139  /// \brief The first range starts after the second range ends.
140  RangeAfter
141};
142
143/// \brief Compare two source ranges to determine their relative position in
144/// the translation unit.
145static RangeComparisonResult RangeCompare(SourceManager &SM,
146                                          SourceRange R1,
147                                          SourceRange R2) {
148  assert(R1.isValid() && "First range is invalid?");
149  assert(R2.isValid() && "Second range is invalid?");
150  if (R1.getEnd() != R2.getBegin() &&
151      SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin()))
152    return RangeBefore;
153  if (R2.getEnd() != R1.getBegin() &&
154      SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin()))
155    return RangeAfter;
156  return RangeOverlap;
157}
158
159/// \brief Determine if a source location falls within, before, or after a
160///   a given source range.
161static RangeComparisonResult LocationCompare(SourceManager &SM,
162                                             SourceLocation L, SourceRange R) {
163  assert(R.isValid() && "First range is invalid?");
164  assert(L.isValid() && "Second range is invalid?");
165  if (L == R.getBegin() || L == R.getEnd())
166    return RangeOverlap;
167  if (SM.isBeforeInTranslationUnit(L, R.getBegin()))
168    return RangeBefore;
169  if (SM.isBeforeInTranslationUnit(R.getEnd(), L))
170    return RangeAfter;
171  return RangeOverlap;
172}
173
174/// \brief Translate a Clang source range into a CIndex source range.
175///
176/// Clang internally represents ranges where the end location points to the
177/// start of the token at the end. However, for external clients it is more
178/// useful to have a CXSourceRange be a proper half-open interval. This routine
179/// does the appropriate translation.
180CXSourceRange cxloc::translateSourceRange(const SourceManager &SM,
181                                          const LangOptions &LangOpts,
182                                          const CharSourceRange &R) {
183  // We want the last character in this location, so we will adjust the
184  // location accordingly.
185  // FIXME: How do do this with a macro instantiation location?
186  SourceLocation EndLoc = R.getEnd();
187  if (R.isTokenRange() && !EndLoc.isInvalid() && EndLoc.isFileID()) {
188    unsigned Length = Lexer::MeasureTokenLength(EndLoc, SM, LangOpts);
189    EndLoc = EndLoc.getFileLocWithOffset(Length);
190  }
191
192  CXSourceRange Result = { { (void *)&SM, (void *)&LangOpts },
193                           R.getBegin().getRawEncoding(),
194                           EndLoc.getRawEncoding() };
195  return Result;
196}
197
198//===----------------------------------------------------------------------===//
199// Cursor visitor.
200//===----------------------------------------------------------------------===//
201
202namespace {
203
204// Cursor visitor.
205class CursorVisitor : public DeclVisitor<CursorVisitor, bool>,
206                      public TypeLocVisitor<CursorVisitor, bool>,
207                      public StmtVisitor<CursorVisitor, bool>
208{
209  /// \brief The translation unit we are traversing.
210  ASTUnit *TU;
211
212  /// \brief The parent cursor whose children we are traversing.
213  CXCursor Parent;
214
215  /// \brief The declaration that serves at the parent of any statement or
216  /// expression nodes.
217  Decl *StmtParent;
218
219  /// \brief The visitor function.
220  CXCursorVisitor Visitor;
221
222  /// \brief The opaque client data, to be passed along to the visitor.
223  CXClientData ClientData;
224
225  // MaxPCHLevel - the maximum PCH level of declarations that we will pass on
226  // to the visitor. Declarations with a PCH level greater than this value will
227  // be suppressed.
228  unsigned MaxPCHLevel;
229
230  /// \brief When valid, a source range to which the cursor should restrict
231  /// its search.
232  SourceRange RegionOfInterest;
233
234  using DeclVisitor<CursorVisitor, bool>::Visit;
235  using TypeLocVisitor<CursorVisitor, bool>::Visit;
236  using StmtVisitor<CursorVisitor, bool>::Visit;
237
238  /// \brief Determine whether this particular source range comes before, comes
239  /// after, or overlaps the region of interest.
240  ///
241  /// \param R a half-open source range retrieved from the abstract syntax tree.
242  RangeComparisonResult CompareRegionOfInterest(SourceRange R);
243
244  class SetParentRAII {
245    CXCursor &Parent;
246    Decl *&StmtParent;
247    CXCursor OldParent;
248
249  public:
250    SetParentRAII(CXCursor &Parent, Decl *&StmtParent, CXCursor NewParent)
251      : Parent(Parent), StmtParent(StmtParent), OldParent(Parent)
252    {
253      Parent = NewParent;
254      if (clang_isDeclaration(Parent.kind))
255        StmtParent = getCursorDecl(Parent);
256    }
257
258    ~SetParentRAII() {
259      Parent = OldParent;
260      if (clang_isDeclaration(Parent.kind))
261        StmtParent = getCursorDecl(Parent);
262    }
263  };
264
265public:
266  CursorVisitor(ASTUnit *TU, CXCursorVisitor Visitor, CXClientData ClientData,
267                unsigned MaxPCHLevel,
268                SourceRange RegionOfInterest = SourceRange())
269    : TU(TU), Visitor(Visitor), ClientData(ClientData),
270      MaxPCHLevel(MaxPCHLevel), RegionOfInterest(RegionOfInterest)
271  {
272    Parent.kind = CXCursor_NoDeclFound;
273    Parent.data[0] = 0;
274    Parent.data[1] = 0;
275    Parent.data[2] = 0;
276    StmtParent = 0;
277  }
278
279  bool Visit(CXCursor Cursor, bool CheckedRegionOfInterest = false);
280
281  std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator>
282    getPreprocessedEntities();
283
284  bool VisitChildren(CXCursor Parent);
285
286  // Declaration visitors
287  bool VisitAttributes(Decl *D);
288  bool VisitBlockDecl(BlockDecl *B);
289  bool VisitCXXRecordDecl(CXXRecordDecl *D);
290  bool VisitDeclContext(DeclContext *DC);
291  bool VisitTranslationUnitDecl(TranslationUnitDecl *D);
292  bool VisitTypedefDecl(TypedefDecl *D);
293  bool VisitTagDecl(TagDecl *D);
294  bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D);
295  bool VisitClassTemplatePartialSpecializationDecl(
296                                     ClassTemplatePartialSpecializationDecl *D);
297  bool VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
298  bool VisitEnumConstantDecl(EnumConstantDecl *D);
299  bool VisitDeclaratorDecl(DeclaratorDecl *DD);
300  bool VisitFunctionDecl(FunctionDecl *ND);
301  bool VisitFieldDecl(FieldDecl *D);
302  bool VisitVarDecl(VarDecl *);
303  bool VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
304  bool VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
305  bool VisitClassTemplateDecl(ClassTemplateDecl *D);
306  bool VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
307  bool VisitObjCMethodDecl(ObjCMethodDecl *ND);
308  bool VisitObjCContainerDecl(ObjCContainerDecl *D);
309  bool VisitObjCCategoryDecl(ObjCCategoryDecl *ND);
310  bool VisitObjCProtocolDecl(ObjCProtocolDecl *PID);
311  bool VisitObjCPropertyDecl(ObjCPropertyDecl *PD);
312  bool VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
313  bool VisitObjCImplDecl(ObjCImplDecl *D);
314  bool VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
315  bool VisitObjCImplementationDecl(ObjCImplementationDecl *D);
316  // FIXME: ObjCCompatibleAliasDecl requires aliased-class locations.
317  bool VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D);
318  bool VisitObjCClassDecl(ObjCClassDecl *D);
319  bool VisitLinkageSpecDecl(LinkageSpecDecl *D);
320  bool VisitNamespaceDecl(NamespaceDecl *D);
321  bool VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
322  bool VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
323  bool VisitUsingDecl(UsingDecl *D);
324  bool VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
325  bool VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
326
327  // Name visitor
328  bool VisitDeclarationNameInfo(DeclarationNameInfo Name);
329  bool VisitNestedNameSpecifier(NestedNameSpecifier *NNS, SourceRange Range);
330
331  // Template visitors
332  bool VisitTemplateParameters(const TemplateParameterList *Params);
333  bool VisitTemplateName(TemplateName Name, SourceLocation Loc);
334  bool VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL);
335
336  // Type visitors
337  bool VisitQualifiedTypeLoc(QualifiedTypeLoc TL);
338  bool VisitBuiltinTypeLoc(BuiltinTypeLoc TL);
339  bool VisitTypedefTypeLoc(TypedefTypeLoc TL);
340  bool VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL);
341  bool VisitTagTypeLoc(TagTypeLoc TL);
342  bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL);
343  bool VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL);
344  bool VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL);
345  bool VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL);
346  bool VisitPointerTypeLoc(PointerTypeLoc TL);
347  bool VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL);
348  bool VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL);
349  bool VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL);
350  bool VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL);
351  bool VisitFunctionTypeLoc(FunctionTypeLoc TL, bool SkipResultType = false);
352  bool VisitArrayTypeLoc(ArrayTypeLoc TL);
353  bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL);
354  // FIXME: Implement visitors here when the unimplemented TypeLocs get
355  // implemented
356  bool VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL);
357  bool VisitTypeOfTypeLoc(TypeOfTypeLoc TL);
358
359  // Statement visitors
360  bool VisitStmt(Stmt *S);
361  bool VisitDeclStmt(DeclStmt *S);
362  // FIXME: LabelStmt label?
363  bool VisitIfStmt(IfStmt *S);
364  bool VisitSwitchStmt(SwitchStmt *S);
365  bool VisitCaseStmt(CaseStmt *S);
366  bool VisitWhileStmt(WhileStmt *S);
367  bool VisitForStmt(ForStmt *S);
368
369  // Expression visitors
370  bool VisitDeclRefExpr(DeclRefExpr *E);
371  bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
372  bool VisitBlockExpr(BlockExpr *B);
373  bool VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
374  bool VisitExplicitCastExpr(ExplicitCastExpr *E);
375  bool VisitObjCMessageExpr(ObjCMessageExpr *E);
376  bool VisitObjCEncodeExpr(ObjCEncodeExpr *E);
377  bool VisitOffsetOfExpr(OffsetOfExpr *E);
378  bool VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E);
379  bool VisitMemberExpr(MemberExpr *E);
380  // FIXME: AddrLabelExpr (once we have cursors for labels)
381  bool VisitTypesCompatibleExpr(TypesCompatibleExpr *E);
382  bool VisitVAArgExpr(VAArgExpr *E);
383  // FIXME: InitListExpr (for the designators)
384  // FIXME: DesignatedInitExpr
385  bool VisitCXXTypeidExpr(CXXTypeidExpr *E);
386  bool VisitCXXUuidofExpr(CXXUuidofExpr *E);
387  bool VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { return false; }
388  bool VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
389  bool VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
390  bool VisitCXXNewExpr(CXXNewExpr *E);
391  bool VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
392  bool VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E);
393  bool VisitOverloadExpr(OverloadExpr *E);
394  bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
395  bool VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
396  bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
397  bool VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
398};
399
400} // end anonymous namespace
401
402static SourceRange getRawCursorExtent(CXCursor C);
403
404RangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) {
405  return RangeCompare(TU->getSourceManager(), R, RegionOfInterest);
406}
407
408/// \brief Visit the given cursor and, if requested by the visitor,
409/// its children.
410///
411/// \param Cursor the cursor to visit.
412///
413/// \param CheckRegionOfInterest if true, then the caller already checked that
414/// this cursor is within the region of interest.
415///
416/// \returns true if the visitation should be aborted, false if it
417/// should continue.
418bool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) {
419  if (clang_isInvalid(Cursor.kind))
420    return false;
421
422  if (clang_isDeclaration(Cursor.kind)) {
423    Decl *D = getCursorDecl(Cursor);
424    assert(D && "Invalid declaration cursor");
425    if (D->getPCHLevel() > MaxPCHLevel)
426      return false;
427
428    if (D->isImplicit())
429      return false;
430  }
431
432  // If we have a range of interest, and this cursor doesn't intersect with it,
433  // we're done.
434  if (RegionOfInterest.isValid() && !CheckedRegionOfInterest) {
435    SourceRange Range = getRawCursorExtent(Cursor);
436    if (Range.isInvalid() || CompareRegionOfInterest(Range))
437      return false;
438  }
439
440  switch (Visitor(Cursor, Parent, ClientData)) {
441  case CXChildVisit_Break:
442    return true;
443
444  case CXChildVisit_Continue:
445    return false;
446
447  case CXChildVisit_Recurse:
448    return VisitChildren(Cursor);
449  }
450
451  return false;
452}
453
454std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator>
455CursorVisitor::getPreprocessedEntities() {
456  PreprocessingRecord &PPRec
457    = *TU->getPreprocessor().getPreprocessingRecord();
458
459  bool OnlyLocalDecls
460    = !TU->isMainFileAST() && TU->getOnlyLocalDecls();
461
462  // There is no region of interest; we have to walk everything.
463  if (RegionOfInterest.isInvalid())
464    return std::make_pair(PPRec.begin(OnlyLocalDecls),
465                          PPRec.end(OnlyLocalDecls));
466
467  // Find the file in which the region of interest lands.
468  SourceManager &SM = TU->getSourceManager();
469  std::pair<FileID, unsigned> Begin
470    = SM.getDecomposedInstantiationLoc(RegionOfInterest.getBegin());
471  std::pair<FileID, unsigned> End
472    = SM.getDecomposedInstantiationLoc(RegionOfInterest.getEnd());
473
474  // The region of interest spans files; we have to walk everything.
475  if (Begin.first != End.first)
476    return std::make_pair(PPRec.begin(OnlyLocalDecls),
477                          PPRec.end(OnlyLocalDecls));
478
479  ASTUnit::PreprocessedEntitiesByFileMap &ByFileMap
480    = TU->getPreprocessedEntitiesByFile();
481  if (ByFileMap.empty()) {
482    // Build the mapping from files to sets of preprocessed entities.
483    for (PreprocessingRecord::iterator E = PPRec.begin(OnlyLocalDecls),
484                                    EEnd = PPRec.end(OnlyLocalDecls);
485         E != EEnd; ++E) {
486      std::pair<FileID, unsigned> P
487        = SM.getDecomposedInstantiationLoc((*E)->getSourceRange().getBegin());
488      ByFileMap[P.first].push_back(*E);
489    }
490  }
491
492  return std::make_pair(ByFileMap[Begin.first].begin(),
493                        ByFileMap[Begin.first].end());
494}
495
496/// \brief Visit the children of the given cursor.
497///
498/// \returns true if the visitation should be aborted, false if it
499/// should continue.
500bool CursorVisitor::VisitChildren(CXCursor Cursor) {
501  if (clang_isReference(Cursor.kind)) {
502    // By definition, references have no children.
503    return false;
504  }
505
506  // Set the Parent field to Cursor, then back to its old value once we're
507  // done.
508  SetParentRAII SetParent(Parent, StmtParent, Cursor);
509
510  if (clang_isDeclaration(Cursor.kind)) {
511    Decl *D = getCursorDecl(Cursor);
512    assert(D && "Invalid declaration cursor");
513    return VisitAttributes(D) || Visit(D);
514  }
515
516  if (clang_isStatement(Cursor.kind))
517    return Visit(getCursorStmt(Cursor));
518  if (clang_isExpression(Cursor.kind))
519    return Visit(getCursorExpr(Cursor));
520
521  if (clang_isTranslationUnit(Cursor.kind)) {
522    ASTUnit *CXXUnit = getCursorASTUnit(Cursor);
523    if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() &&
524        RegionOfInterest.isInvalid()) {
525      for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(),
526                                    TLEnd = CXXUnit->top_level_end();
527           TL != TLEnd; ++TL) {
528        if (Visit(MakeCXCursor(*TL, CXXUnit), true))
529          return true;
530      }
531    } else if (VisitDeclContext(
532                            CXXUnit->getASTContext().getTranslationUnitDecl()))
533      return true;
534
535    // Walk the preprocessing record.
536    if (CXXUnit->getPreprocessor().getPreprocessingRecord()) {
537      // FIXME: Once we have the ability to deserialize a preprocessing record,
538      // do so.
539      PreprocessingRecord::iterator E, EEnd;
540      for (llvm::tie(E, EEnd) = getPreprocessedEntities(); E != EEnd; ++E) {
541        if (MacroInstantiation *MI = dyn_cast<MacroInstantiation>(*E)) {
542          if (Visit(MakeMacroInstantiationCursor(MI, CXXUnit)))
543            return true;
544
545          continue;
546        }
547
548        if (MacroDefinition *MD = dyn_cast<MacroDefinition>(*E)) {
549          if (Visit(MakeMacroDefinitionCursor(MD, CXXUnit)))
550            return true;
551
552          continue;
553        }
554      }
555    }
556    return false;
557  }
558
559  // Nothing to visit at the moment.
560  return false;
561}
562
563bool CursorVisitor::VisitBlockDecl(BlockDecl *B) {
564  if (Visit(B->getSignatureAsWritten()->getTypeLoc()))
565    return true;
566
567  if (Stmt *Body = B->getBody())
568    return Visit(MakeCXCursor(Body, StmtParent, TU));
569
570  return false;
571}
572
573bool CursorVisitor::VisitDeclContext(DeclContext *DC) {
574  for (DeclContext::decl_iterator
575       I = DC->decls_begin(), E = DC->decls_end(); I != E; ++I) {
576
577    Decl *D = *I;
578    if (D->getLexicalDeclContext() != DC)
579      continue;
580
581    CXCursor Cursor = MakeCXCursor(D, TU);
582
583    if (RegionOfInterest.isValid()) {
584      SourceRange Range = getRawCursorExtent(Cursor);
585      if (Range.isInvalid())
586        continue;
587
588      switch (CompareRegionOfInterest(Range)) {
589      case RangeBefore:
590        // This declaration comes before the region of interest; skip it.
591        continue;
592
593      case RangeAfter:
594        // This declaration comes after the region of interest; we're done.
595        return false;
596
597      case RangeOverlap:
598        // This declaration overlaps the region of interest; visit it.
599        break;
600      }
601    }
602
603    if (Visit(Cursor, true))
604      return true;
605  }
606
607  return false;
608}
609
610bool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
611  llvm_unreachable("Translation units are visited directly by Visit()");
612  return false;
613}
614
615bool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) {
616  if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo())
617    return Visit(TSInfo->getTypeLoc());
618
619  return false;
620}
621
622bool CursorVisitor::VisitTagDecl(TagDecl *D) {
623  return VisitDeclContext(D);
624}
625
626bool CursorVisitor::VisitClassTemplateSpecializationDecl(
627                                          ClassTemplateSpecializationDecl *D) {
628  bool ShouldVisitBody = false;
629  switch (D->getSpecializationKind()) {
630  case TSK_Undeclared:
631  case TSK_ImplicitInstantiation:
632    // Nothing to visit
633    return false;
634
635  case TSK_ExplicitInstantiationDeclaration:
636  case TSK_ExplicitInstantiationDefinition:
637    break;
638
639  case TSK_ExplicitSpecialization:
640    ShouldVisitBody = true;
641    break;
642  }
643
644  // Visit the template arguments used in the specialization.
645  if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) {
646    TypeLoc TL = SpecType->getTypeLoc();
647    if (TemplateSpecializationTypeLoc *TSTLoc
648          = dyn_cast<TemplateSpecializationTypeLoc>(&TL)) {
649      for (unsigned I = 0, N = TSTLoc->getNumArgs(); I != N; ++I)
650        if (VisitTemplateArgumentLoc(TSTLoc->getArgLoc(I)))
651          return true;
652    }
653  }
654
655  if (ShouldVisitBody && VisitCXXRecordDecl(D))
656    return true;
657
658  return false;
659}
660
661bool CursorVisitor::VisitClassTemplatePartialSpecializationDecl(
662                                   ClassTemplatePartialSpecializationDecl *D) {
663  // FIXME: Visit the "outer" template parameter lists on the TagDecl
664  // before visiting these template parameters.
665  if (VisitTemplateParameters(D->getTemplateParameters()))
666    return true;
667
668  // Visit the partial specialization arguments.
669  const TemplateArgumentLoc *TemplateArgs = D->getTemplateArgsAsWritten();
670  for (unsigned I = 0, N = D->getNumTemplateArgsAsWritten(); I != N; ++I)
671    if (VisitTemplateArgumentLoc(TemplateArgs[I]))
672      return true;
673
674  return VisitCXXRecordDecl(D);
675}
676
677bool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
678  // Visit the default argument.
679  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
680    if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo())
681      if (Visit(DefArg->getTypeLoc()))
682        return true;
683
684  return false;
685}
686
687bool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) {
688  if (Expr *Init = D->getInitExpr())
689    return Visit(MakeCXCursor(Init, StmtParent, TU));
690  return false;
691}
692
693bool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) {
694  if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo())
695    if (Visit(TSInfo->getTypeLoc()))
696      return true;
697
698  return false;
699}
700
701/// \brief Compare two base or member initializers based on their source order.
702static int CompareCXXBaseOrMemberInitializers(const void* Xp, const void *Yp) {
703  CXXBaseOrMemberInitializer const * const *X
704    = static_cast<CXXBaseOrMemberInitializer const * const *>(Xp);
705  CXXBaseOrMemberInitializer const * const *Y
706    = static_cast<CXXBaseOrMemberInitializer const * const *>(Yp);
707
708  if ((*X)->getSourceOrder() < (*Y)->getSourceOrder())
709    return -1;
710  else if ((*X)->getSourceOrder() > (*Y)->getSourceOrder())
711    return 1;
712  else
713    return 0;
714}
715
716bool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) {
717  if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) {
718    // Visit the function declaration's syntactic components in the order
719    // written. This requires a bit of work.
720    TypeLoc TL = TSInfo->getTypeLoc();
721    FunctionTypeLoc *FTL = dyn_cast<FunctionTypeLoc>(&TL);
722
723    // If we have a function declared directly (without the use of a typedef),
724    // visit just the return type. Otherwise, just visit the function's type
725    // now.
726    if ((FTL && !isa<CXXConversionDecl>(ND) && Visit(FTL->getResultLoc())) ||
727        (!FTL && Visit(TL)))
728      return true;
729
730    // Visit the nested-name-specifier, if present.
731    if (NestedNameSpecifier *Qualifier = ND->getQualifier())
732      if (VisitNestedNameSpecifier(Qualifier, ND->getQualifierRange()))
733        return true;
734
735    // Visit the declaration name.
736    if (VisitDeclarationNameInfo(ND->getNameInfo()))
737      return true;
738
739    // FIXME: Visit explicitly-specified template arguments!
740
741    // Visit the function parameters, if we have a function type.
742    if (FTL && VisitFunctionTypeLoc(*FTL, true))
743      return true;
744
745    // FIXME: Attributes?
746  }
747
748  if (ND->isThisDeclarationADefinition()) {
749    if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) {
750      // Find the initializers that were written in the source.
751      llvm::SmallVector<CXXBaseOrMemberInitializer *, 4> WrittenInits;
752      for (CXXConstructorDecl::init_iterator I = Constructor->init_begin(),
753                                          IEnd = Constructor->init_end();
754           I != IEnd; ++I) {
755        if (!(*I)->isWritten())
756          continue;
757
758        WrittenInits.push_back(*I);
759      }
760
761      // Sort the initializers in source order
762      llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(),
763                           &CompareCXXBaseOrMemberInitializers);
764
765      // Visit the initializers in source order
766      for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) {
767        CXXBaseOrMemberInitializer *Init = WrittenInits[I];
768        if (Init->isMemberInitializer()) {
769          if (Visit(MakeCursorMemberRef(Init->getMember(),
770                                        Init->getMemberLocation(), TU)))
771            return true;
772        } else if (TypeSourceInfo *BaseInfo = Init->getBaseClassInfo()) {
773          if (Visit(BaseInfo->getTypeLoc()))
774            return true;
775        }
776
777        // Visit the initializer value.
778        if (Expr *Initializer = Init->getInit())
779          if (Visit(MakeCXCursor(Initializer, ND, TU)))
780            return true;
781      }
782    }
783
784    if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU)))
785      return true;
786  }
787
788  return false;
789}
790
791bool CursorVisitor::VisitFieldDecl(FieldDecl *D) {
792  if (VisitDeclaratorDecl(D))
793    return true;
794
795  if (Expr *BitWidth = D->getBitWidth())
796    return Visit(MakeCXCursor(BitWidth, StmtParent, TU));
797
798  return false;
799}
800
801bool CursorVisitor::VisitVarDecl(VarDecl *D) {
802  if (VisitDeclaratorDecl(D))
803    return true;
804
805  if (Expr *Init = D->getInit())
806    return Visit(MakeCXCursor(Init, StmtParent, TU));
807
808  return false;
809}
810
811bool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
812  if (VisitDeclaratorDecl(D))
813    return true;
814
815  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
816    if (Expr *DefArg = D->getDefaultArgument())
817      return Visit(MakeCXCursor(DefArg, StmtParent, TU));
818
819  return false;
820}
821
822bool CursorVisitor::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
823  // FIXME: Visit the "outer" template parameter lists on the FunctionDecl
824  // before visiting these template parameters.
825  if (VisitTemplateParameters(D->getTemplateParameters()))
826    return true;
827
828  return VisitFunctionDecl(D->getTemplatedDecl());
829}
830
831bool CursorVisitor::VisitClassTemplateDecl(ClassTemplateDecl *D) {
832  // FIXME: Visit the "outer" template parameter lists on the TagDecl
833  // before visiting these template parameters.
834  if (VisitTemplateParameters(D->getTemplateParameters()))
835    return true;
836
837  return VisitCXXRecordDecl(D->getTemplatedDecl());
838}
839
840bool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
841  if (VisitTemplateParameters(D->getTemplateParameters()))
842    return true;
843
844  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() &&
845      VisitTemplateArgumentLoc(D->getDefaultArgument()))
846    return true;
847
848  return false;
849}
850
851bool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) {
852  if (TypeSourceInfo *TSInfo = ND->getResultTypeSourceInfo())
853    if (Visit(TSInfo->getTypeLoc()))
854      return true;
855
856  for (ObjCMethodDecl::param_iterator P = ND->param_begin(),
857       PEnd = ND->param_end();
858       P != PEnd; ++P) {
859    if (Visit(MakeCXCursor(*P, TU)))
860      return true;
861  }
862
863  if (ND->isThisDeclarationADefinition() &&
864      Visit(MakeCXCursor(ND->getBody(), StmtParent, TU)))
865    return true;
866
867  return false;
868}
869
870bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) {
871  return VisitDeclContext(D);
872}
873
874bool CursorVisitor::VisitObjCCategoryDecl(ObjCCategoryDecl *ND) {
875  if (Visit(MakeCursorObjCClassRef(ND->getClassInterface(), ND->getLocation(),
876                                   TU)))
877    return true;
878
879  ObjCCategoryDecl::protocol_loc_iterator PL = ND->protocol_loc_begin();
880  for (ObjCCategoryDecl::protocol_iterator I = ND->protocol_begin(),
881         E = ND->protocol_end(); I != E; ++I, ++PL)
882    if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
883      return true;
884
885  return VisitObjCContainerDecl(ND);
886}
887
888bool CursorVisitor::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) {
889  ObjCProtocolDecl::protocol_loc_iterator PL = PID->protocol_loc_begin();
890  for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(),
891       E = PID->protocol_end(); I != E; ++I, ++PL)
892    if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
893      return true;
894
895  return VisitObjCContainerDecl(PID);
896}
897
898bool CursorVisitor::VisitObjCPropertyDecl(ObjCPropertyDecl *PD) {
899  if (PD->getTypeSourceInfo() && Visit(PD->getTypeSourceInfo()->getTypeLoc()))
900    return true;
901
902  // FIXME: This implements a workaround with @property declarations also being
903  // installed in the DeclContext for the @interface.  Eventually this code
904  // should be removed.
905  ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(PD->getDeclContext());
906  if (!CDecl || !CDecl->IsClassExtension())
907    return false;
908
909  ObjCInterfaceDecl *ID = CDecl->getClassInterface();
910  if (!ID)
911    return false;
912
913  IdentifierInfo *PropertyId = PD->getIdentifier();
914  ObjCPropertyDecl *prevDecl =
915    ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(ID), PropertyId);
916
917  if (!prevDecl)
918    return false;
919
920  // Visit synthesized methods since they will be skipped when visiting
921  // the @interface.
922  if (ObjCMethodDecl *MD = prevDecl->getGetterMethodDecl())
923    if (MD->isSynthesized())
924      if (Visit(MakeCXCursor(MD, TU)))
925        return true;
926
927  if (ObjCMethodDecl *MD = prevDecl->getSetterMethodDecl())
928    if (MD->isSynthesized())
929      if (Visit(MakeCXCursor(MD, TU)))
930        return true;
931
932  return false;
933}
934
935bool CursorVisitor::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
936  // Issue callbacks for super class.
937  if (D->getSuperClass() &&
938      Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(),
939                                        D->getSuperClassLoc(),
940                                        TU)))
941    return true;
942
943  ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin();
944  for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(),
945         E = D->protocol_end(); I != E; ++I, ++PL)
946    if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
947      return true;
948
949  return VisitObjCContainerDecl(D);
950}
951
952bool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) {
953  return VisitObjCContainerDecl(D);
954}
955
956bool CursorVisitor::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
957  // 'ID' could be null when dealing with invalid code.
958  if (ObjCInterfaceDecl *ID = D->getClassInterface())
959    if (Visit(MakeCursorObjCClassRef(ID, D->getLocation(), TU)))
960      return true;
961
962  return VisitObjCImplDecl(D);
963}
964
965bool CursorVisitor::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
966#if 0
967  // Issue callbacks for super class.
968  // FIXME: No source location information!
969  if (D->getSuperClass() &&
970      Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(),
971                                        D->getSuperClassLoc(),
972                                        TU)))
973    return true;
974#endif
975
976  return VisitObjCImplDecl(D);
977}
978
979bool CursorVisitor::VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D) {
980  ObjCForwardProtocolDecl::protocol_loc_iterator PL = D->protocol_loc_begin();
981  for (ObjCForwardProtocolDecl::protocol_iterator I = D->protocol_begin(),
982                                                  E = D->protocol_end();
983       I != E; ++I, ++PL)
984    if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU)))
985      return true;
986
987  return false;
988}
989
990bool CursorVisitor::VisitObjCClassDecl(ObjCClassDecl *D) {
991  for (ObjCClassDecl::iterator C = D->begin(), CEnd = D->end(); C != CEnd; ++C)
992    if (Visit(MakeCursorObjCClassRef(C->getInterface(), C->getLocation(), TU)))
993      return true;
994
995  return false;
996}
997
998bool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) {
999  return VisitDeclContext(D);
1000}
1001
1002bool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1003  // Visit nested-name-specifier.
1004  if (NestedNameSpecifier *Qualifier = D->getQualifier())
1005    if (VisitNestedNameSpecifier(Qualifier, D->getQualifierRange()))
1006      return true;
1007
1008  return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(),
1009                                      D->getTargetNameLoc(), TU));
1010}
1011
1012bool CursorVisitor::VisitUsingDecl(UsingDecl *D) {
1013  // Visit nested-name-specifier.
1014  if (NestedNameSpecifier *Qualifier = D->getTargetNestedNameDecl())
1015    if (VisitNestedNameSpecifier(Qualifier, D->getNestedNameRange()))
1016      return true;
1017
1018  // FIXME: Provide a multi-reference of some kind for all of the declarations
1019  // that the using declaration refers to. We don't have this kind of cursor
1020  // yet.
1021
1022  return VisitDeclarationNameInfo(D->getNameInfo());
1023}
1024
1025bool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1026  // Visit nested-name-specifier.
1027  if (NestedNameSpecifier *Qualifier = D->getQualifier())
1028    if (VisitNestedNameSpecifier(Qualifier, D->getQualifierRange()))
1029      return true;
1030
1031  return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(),
1032                                      D->getIdentLocation(), TU));
1033}
1034
1035bool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1036  // Visit nested-name-specifier.
1037  if (NestedNameSpecifier *Qualifier = D->getTargetNestedNameSpecifier())
1038    if (VisitNestedNameSpecifier(Qualifier, D->getTargetNestedNameRange()))
1039      return true;
1040
1041  return VisitDeclarationNameInfo(D->getNameInfo());
1042}
1043
1044bool CursorVisitor::VisitUnresolvedUsingTypenameDecl(
1045                                               UnresolvedUsingTypenameDecl *D) {
1046  // Visit nested-name-specifier.
1047  if (NestedNameSpecifier *Qualifier = D->getTargetNestedNameSpecifier())
1048    if (VisitNestedNameSpecifier(Qualifier, D->getTargetNestedNameRange()))
1049      return true;
1050
1051  return false;
1052}
1053
1054bool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) {
1055  switch (Name.getName().getNameKind()) {
1056  case clang::DeclarationName::Identifier:
1057  case clang::DeclarationName::CXXLiteralOperatorName:
1058  case clang::DeclarationName::CXXOperatorName:
1059  case clang::DeclarationName::CXXUsingDirective:
1060    return false;
1061
1062  case clang::DeclarationName::CXXConstructorName:
1063  case clang::DeclarationName::CXXDestructorName:
1064  case clang::DeclarationName::CXXConversionFunctionName:
1065    if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo())
1066      return Visit(TSInfo->getTypeLoc());
1067    return false;
1068
1069  case clang::DeclarationName::ObjCZeroArgSelector:
1070  case clang::DeclarationName::ObjCOneArgSelector:
1071  case clang::DeclarationName::ObjCMultiArgSelector:
1072    // FIXME: Per-identifier location info?
1073    return false;
1074  }
1075
1076  return false;
1077}
1078
1079bool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS,
1080                                             SourceRange Range) {
1081  // FIXME: This whole routine is a hack to work around the lack of proper
1082  // source information in nested-name-specifiers (PR5791). Since we do have
1083  // a beginning source location, we can visit the first component of the
1084  // nested-name-specifier, if it's a single-token component.
1085  if (!NNS)
1086    return false;
1087
1088  // Get the first component in the nested-name-specifier.
1089  while (NestedNameSpecifier *Prefix = NNS->getPrefix())
1090    NNS = Prefix;
1091
1092  switch (NNS->getKind()) {
1093  case NestedNameSpecifier::Namespace:
1094    // FIXME: The token at this source location might actually have been a
1095    // namespace alias, but we don't model that. Lame!
1096    return Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(),
1097                                        TU));
1098
1099  case NestedNameSpecifier::TypeSpec: {
1100    // If the type has a form where we know that the beginning of the source
1101    // range matches up with a reference cursor. Visit the appropriate reference
1102    // cursor.
1103    Type *T = NNS->getAsType();
1104    if (const TypedefType *Typedef = dyn_cast<TypedefType>(T))
1105      return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU));
1106    if (const TagType *Tag = dyn_cast<TagType>(T))
1107      return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU));
1108    if (const TemplateSpecializationType *TST
1109                                      = dyn_cast<TemplateSpecializationType>(T))
1110      return VisitTemplateName(TST->getTemplateName(), Range.getBegin());
1111    break;
1112  }
1113
1114  case NestedNameSpecifier::TypeSpecWithTemplate:
1115  case NestedNameSpecifier::Global:
1116  case NestedNameSpecifier::Identifier:
1117    break;
1118  }
1119
1120  return false;
1121}
1122
1123bool CursorVisitor::VisitTemplateParameters(
1124                                          const TemplateParameterList *Params) {
1125  if (!Params)
1126    return false;
1127
1128  for (TemplateParameterList::const_iterator P = Params->begin(),
1129                                          PEnd = Params->end();
1130       P != PEnd; ++P) {
1131    if (Visit(MakeCXCursor(*P, TU)))
1132      return true;
1133  }
1134
1135  return false;
1136}
1137
1138bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) {
1139  switch (Name.getKind()) {
1140  case TemplateName::Template:
1141    return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU));
1142
1143  case TemplateName::OverloadedTemplate:
1144    // FIXME: We need a way to return multiple lookup results in a single
1145    // cursor.
1146    return false;
1147
1148  case TemplateName::DependentTemplate:
1149    // FIXME: Visit nested-name-specifier.
1150    return false;
1151
1152  case TemplateName::QualifiedTemplate:
1153    // FIXME: Visit nested-name-specifier.
1154    return Visit(MakeCursorTemplateRef(
1155                                  Name.getAsQualifiedTemplateName()->getDecl(),
1156                                       Loc, TU));
1157  }
1158
1159  return false;
1160}
1161
1162bool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) {
1163  switch (TAL.getArgument().getKind()) {
1164  case TemplateArgument::Null:
1165  case TemplateArgument::Integral:
1166    return false;
1167
1168  case TemplateArgument::Pack:
1169    // FIXME: Implement when variadic templates come along.
1170    return false;
1171
1172  case TemplateArgument::Type:
1173    if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo())
1174      return Visit(TSInfo->getTypeLoc());
1175    return false;
1176
1177  case TemplateArgument::Declaration:
1178    if (Expr *E = TAL.getSourceDeclExpression())
1179      return Visit(MakeCXCursor(E, StmtParent, TU));
1180    return false;
1181
1182  case TemplateArgument::Expression:
1183    if (Expr *E = TAL.getSourceExpression())
1184      return Visit(MakeCXCursor(E, StmtParent, TU));
1185    return false;
1186
1187  case TemplateArgument::Template:
1188    return VisitTemplateName(TAL.getArgument().getAsTemplate(),
1189                             TAL.getTemplateNameLoc());
1190  }
1191
1192  return false;
1193}
1194
1195bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1196  return VisitDeclContext(D);
1197}
1198
1199bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
1200  return Visit(TL.getUnqualifiedLoc());
1201}
1202
1203bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
1204  ASTContext &Context = TU->getASTContext();
1205
1206  // Some builtin types (such as Objective-C's "id", "sel", and
1207  // "Class") have associated declarations. Create cursors for those.
1208  QualType VisitType;
1209  switch (TL.getType()->getAs<BuiltinType>()->getKind()) {
1210  case BuiltinType::Void:
1211  case BuiltinType::Bool:
1212  case BuiltinType::Char_U:
1213  case BuiltinType::UChar:
1214  case BuiltinType::Char16:
1215  case BuiltinType::Char32:
1216  case BuiltinType::UShort:
1217  case BuiltinType::UInt:
1218  case BuiltinType::ULong:
1219  case BuiltinType::ULongLong:
1220  case BuiltinType::UInt128:
1221  case BuiltinType::Char_S:
1222  case BuiltinType::SChar:
1223  case BuiltinType::WChar:
1224  case BuiltinType::Short:
1225  case BuiltinType::Int:
1226  case BuiltinType::Long:
1227  case BuiltinType::LongLong:
1228  case BuiltinType::Int128:
1229  case BuiltinType::Float:
1230  case BuiltinType::Double:
1231  case BuiltinType::LongDouble:
1232  case BuiltinType::NullPtr:
1233  case BuiltinType::Overload:
1234  case BuiltinType::Dependent:
1235    break;
1236
1237  case BuiltinType::UndeducedAuto: // FIXME: Deserves a cursor?
1238    break;
1239
1240  case BuiltinType::ObjCId:
1241    VisitType = Context.getObjCIdType();
1242    break;
1243
1244  case BuiltinType::ObjCClass:
1245    VisitType = Context.getObjCClassType();
1246    break;
1247
1248  case BuiltinType::ObjCSel:
1249    VisitType = Context.getObjCSelType();
1250    break;
1251  }
1252
1253  if (!VisitType.isNull()) {
1254    if (const TypedefType *Typedef = VisitType->getAs<TypedefType>())
1255      return Visit(MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(),
1256                                     TU));
1257  }
1258
1259  return false;
1260}
1261
1262bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
1263  return Visit(MakeCursorTypeRef(TL.getTypedefDecl(), TL.getNameLoc(), TU));
1264}
1265
1266bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
1267  return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1268}
1269
1270bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) {
1271  return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU));
1272}
1273
1274bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
1275  // FIXME: We can't visit the template template parameter, but there's
1276  // no context information with which we can match up the depth/index in the
1277  // type to the appropriate
1278  return false;
1279}
1280
1281bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
1282  if (Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU)))
1283    return true;
1284
1285  return false;
1286}
1287
1288bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
1289  if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc()))
1290    return true;
1291
1292  for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
1293    if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I),
1294                                        TU)))
1295      return true;
1296  }
1297
1298  return false;
1299}
1300
1301bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
1302  return Visit(TL.getPointeeLoc());
1303}
1304
1305bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) {
1306  return Visit(TL.getPointeeLoc());
1307}
1308
1309bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
1310  return Visit(TL.getPointeeLoc());
1311}
1312
1313bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
1314  return Visit(TL.getPointeeLoc());
1315}
1316
1317bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
1318  return Visit(TL.getPointeeLoc());
1319}
1320
1321bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
1322  return Visit(TL.getPointeeLoc());
1323}
1324
1325bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL,
1326                                         bool SkipResultType) {
1327  if (!SkipResultType && Visit(TL.getResultLoc()))
1328    return true;
1329
1330  for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1331    if (Decl *D = TL.getArg(I))
1332      if (Visit(MakeCXCursor(D, TU)))
1333        return true;
1334
1335  return false;
1336}
1337
1338bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) {
1339  if (Visit(TL.getElementLoc()))
1340    return true;
1341
1342  if (Expr *Size = TL.getSizeExpr())
1343    return Visit(MakeCXCursor(Size, StmtParent, TU));
1344
1345  return false;
1346}
1347
1348bool CursorVisitor::VisitTemplateSpecializationTypeLoc(
1349                                             TemplateSpecializationTypeLoc TL) {
1350  // Visit the template name.
1351  if (VisitTemplateName(TL.getTypePtr()->getTemplateName(),
1352                        TL.getTemplateNameLoc()))
1353    return true;
1354
1355  // Visit the template arguments.
1356  for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I)
1357    if (VisitTemplateArgumentLoc(TL.getArgLoc(I)))
1358      return true;
1359
1360  return false;
1361}
1362
1363bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
1364  return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU));
1365}
1366
1367bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
1368  if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo())
1369    return Visit(TSInfo->getTypeLoc());
1370
1371  return false;
1372}
1373
1374bool CursorVisitor::VisitStmt(Stmt *S) {
1375  for (Stmt::child_iterator Child = S->child_begin(), ChildEnd = S->child_end();
1376       Child != ChildEnd; ++Child) {
1377    if (Stmt *C = *Child)
1378      if (Visit(MakeCXCursor(C, StmtParent, TU)))
1379        return true;
1380  }
1381
1382  return false;
1383}
1384
1385bool CursorVisitor::VisitCaseStmt(CaseStmt *S) {
1386  // Specially handle CaseStmts because they can be nested, e.g.:
1387  //
1388  //    case 1:
1389  //    case 2:
1390  //
1391  // In this case the second CaseStmt is the child of the first.  Walking
1392  // these recursively can blow out the stack.
1393  CXCursor Cursor = MakeCXCursor(S, StmtParent, TU);
1394  while (true) {
1395    // Set the Parent field to Cursor, then back to its old value once we're
1396    //   done.
1397    SetParentRAII SetParent(Parent, StmtParent, Cursor);
1398
1399    if (Stmt *LHS = S->getLHS())
1400      if (Visit(MakeCXCursor(LHS, StmtParent, TU)))
1401        return true;
1402    if (Stmt *RHS = S->getRHS())
1403      if (Visit(MakeCXCursor(RHS, StmtParent, TU)))
1404        return true;
1405    if (Stmt *SubStmt = S->getSubStmt()) {
1406      if (!isa<CaseStmt>(SubStmt))
1407        return Visit(MakeCXCursor(SubStmt, StmtParent, TU));
1408
1409      // Specially handle 'CaseStmt' so that we don't blow out the stack.
1410      CaseStmt *CS = cast<CaseStmt>(SubStmt);
1411      Cursor = MakeCXCursor(CS, StmtParent, TU);
1412      if (RegionOfInterest.isValid()) {
1413        SourceRange Range = CS->getSourceRange();
1414        if (Range.isInvalid() || CompareRegionOfInterest(Range))
1415          return false;
1416      }
1417
1418      switch (Visitor(Cursor, Parent, ClientData)) {
1419        case CXChildVisit_Break: return true;
1420        case CXChildVisit_Continue: return false;
1421        case CXChildVisit_Recurse:
1422          // Perform tail-recursion manually.
1423          S = CS;
1424          continue;
1425      }
1426    }
1427    return false;
1428  }
1429}
1430
1431bool CursorVisitor::VisitDeclStmt(DeclStmt *S) {
1432  for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end();
1433       D != DEnd; ++D) {
1434    if (*D && Visit(MakeCXCursor(*D, TU)))
1435      return true;
1436  }
1437
1438  return false;
1439}
1440
1441bool CursorVisitor::VisitIfStmt(IfStmt *S) {
1442  if (VarDecl *Var = S->getConditionVariable()) {
1443    if (Visit(MakeCXCursor(Var, TU)))
1444      return true;
1445  }
1446
1447  if (S->getCond() && Visit(MakeCXCursor(S->getCond(), StmtParent, TU)))
1448    return true;
1449  if (S->getThen() && Visit(MakeCXCursor(S->getThen(), StmtParent, TU)))
1450    return true;
1451  if (S->getElse() && Visit(MakeCXCursor(S->getElse(), StmtParent, TU)))
1452    return true;
1453
1454  return false;
1455}
1456
1457bool CursorVisitor::VisitSwitchStmt(SwitchStmt *S) {
1458  if (VarDecl *Var = S->getConditionVariable()) {
1459    if (Visit(MakeCXCursor(Var, TU)))
1460      return true;
1461  }
1462
1463  if (S->getCond() && Visit(MakeCXCursor(S->getCond(), StmtParent, TU)))
1464    return true;
1465  if (S->getBody() && Visit(MakeCXCursor(S->getBody(), StmtParent, TU)))
1466    return true;
1467
1468  return false;
1469}
1470
1471bool CursorVisitor::VisitWhileStmt(WhileStmt *S) {
1472  if (VarDecl *Var = S->getConditionVariable()) {
1473    if (Visit(MakeCXCursor(Var, TU)))
1474      return true;
1475  }
1476
1477  if (S->getCond() && Visit(MakeCXCursor(S->getCond(), StmtParent, TU)))
1478    return true;
1479  if (S->getBody() && Visit(MakeCXCursor(S->getBody(), StmtParent, TU)))
1480    return true;
1481
1482  return false;
1483}
1484
1485bool CursorVisitor::VisitForStmt(ForStmt *S) {
1486  if (S->getInit() && Visit(MakeCXCursor(S->getInit(), StmtParent, TU)))
1487    return true;
1488  if (VarDecl *Var = S->getConditionVariable()) {
1489    if (Visit(MakeCXCursor(Var, TU)))
1490      return true;
1491  }
1492
1493  if (S->getCond() && Visit(MakeCXCursor(S->getCond(), StmtParent, TU)))
1494    return true;
1495  if (S->getInc() && Visit(MakeCXCursor(S->getInc(), StmtParent, TU)))
1496    return true;
1497  if (S->getBody() && Visit(MakeCXCursor(S->getBody(), StmtParent, TU)))
1498    return true;
1499
1500  return false;
1501}
1502
1503bool CursorVisitor::VisitDeclRefExpr(DeclRefExpr *E) {
1504  // Visit nested-name-specifier, if present.
1505  if (NestedNameSpecifier *Qualifier = E->getQualifier())
1506    if (VisitNestedNameSpecifier(Qualifier, E->getQualifierRange()))
1507      return true;
1508
1509  // Visit declaration name.
1510  if (VisitDeclarationNameInfo(E->getNameInfo()))
1511    return true;
1512
1513  // Visit explicitly-specified template arguments.
1514  if (E->hasExplicitTemplateArgs()) {
1515    ExplicitTemplateArgumentList &Args = E->getExplicitTemplateArgs();
1516    for (TemplateArgumentLoc *Arg = Args.getTemplateArgs(),
1517                          *ArgEnd = Arg + Args.NumTemplateArgs;
1518         Arg != ArgEnd; ++Arg)
1519      if (VisitTemplateArgumentLoc(*Arg))
1520        return true;
1521  }
1522
1523  return false;
1524}
1525
1526bool CursorVisitor::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1527  if (Visit(MakeCXCursor(E->getArg(0), StmtParent, TU)))
1528    return true;
1529
1530  if (Visit(MakeCXCursor(E->getCallee(), StmtParent, TU)))
1531    return true;
1532
1533  for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I)
1534    if (Visit(MakeCXCursor(E->getArg(I), StmtParent, TU)))
1535      return true;
1536
1537  return false;
1538}
1539
1540bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) {
1541  if (D->isDefinition()) {
1542    for (CXXRecordDecl::base_class_iterator I = D->bases_begin(),
1543         E = D->bases_end(); I != E; ++I) {
1544      if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(I, TU)))
1545        return true;
1546    }
1547  }
1548
1549  return VisitTagDecl(D);
1550}
1551
1552
1553bool CursorVisitor::VisitBlockExpr(BlockExpr *B) {
1554  return Visit(B->getBlockDecl());
1555}
1556
1557bool CursorVisitor::VisitOffsetOfExpr(OffsetOfExpr *E) {
1558  // FIXME: Visit fields as well?
1559  if (Visit(E->getTypeSourceInfo()->getTypeLoc()))
1560    return true;
1561
1562  return VisitExpr(E);
1563}
1564
1565bool CursorVisitor::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
1566  if (E->isArgumentType()) {
1567    if (TypeSourceInfo *TSInfo = E->getArgumentTypeInfo())
1568      return Visit(TSInfo->getTypeLoc());
1569
1570    return false;
1571  }
1572
1573  return VisitExpr(E);
1574}
1575
1576bool CursorVisitor::VisitMemberExpr(MemberExpr *E) {
1577  // Visit the base expression.
1578  if (Visit(MakeCXCursor(E->getBase(), StmtParent, TU)))
1579    return true;
1580
1581  // Visit the nested-name-specifier
1582  if (NestedNameSpecifier *Qualifier = E->getQualifier())
1583    if (VisitNestedNameSpecifier(Qualifier, E->getQualifierRange()))
1584      return true;
1585
1586  // Visit the declaration name.
1587  if (VisitDeclarationNameInfo(E->getMemberNameInfo()))
1588    return true;
1589
1590  // Visit the explicitly-specified template arguments, if any.
1591  if (E->hasExplicitTemplateArgs()) {
1592    for (const TemplateArgumentLoc *Arg = E->getTemplateArgs(),
1593                                *ArgEnd = Arg + E->getNumTemplateArgs();
1594         Arg != ArgEnd;
1595         ++Arg) {
1596      if (VisitTemplateArgumentLoc(*Arg))
1597        return true;
1598    }
1599  }
1600
1601  return false;
1602}
1603
1604bool CursorVisitor::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1605  if (TypeSourceInfo *TSInfo = E->getTypeInfoAsWritten())
1606    if (Visit(TSInfo->getTypeLoc()))
1607      return true;
1608
1609  return VisitCastExpr(E);
1610}
1611
1612bool CursorVisitor::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1613  if (TypeSourceInfo *TSInfo = E->getTypeSourceInfo())
1614    if (Visit(TSInfo->getTypeLoc()))
1615      return true;
1616
1617  return VisitExpr(E);
1618}
1619
1620bool CursorVisitor::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) {
1621  return Visit(E->getArgTInfo1()->getTypeLoc()) ||
1622         Visit(E->getArgTInfo2()->getTypeLoc());
1623}
1624
1625bool CursorVisitor::VisitVAArgExpr(VAArgExpr *E) {
1626  if (Visit(E->getWrittenTypeInfo()->getTypeLoc()))
1627    return true;
1628
1629  return Visit(MakeCXCursor(E->getSubExpr(), StmtParent, TU));
1630}
1631
1632bool CursorVisitor::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1633  if (E->isTypeOperand()) {
1634    if (TypeSourceInfo *TSInfo = E->getTypeOperandSourceInfo())
1635      return Visit(TSInfo->getTypeLoc());
1636
1637    return false;
1638  }
1639
1640  return VisitExpr(E);
1641}
1642
1643bool CursorVisitor::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1644  if (E->isTypeOperand()) {
1645    if (TypeSourceInfo *TSInfo = E->getTypeOperandSourceInfo())
1646      return Visit(TSInfo->getTypeLoc());
1647
1648    return false;
1649  }
1650
1651  return VisitExpr(E);
1652}
1653
1654bool CursorVisitor::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1655  if (TypeSourceInfo *TSInfo = E->getTypeSourceInfo())
1656    return Visit(TSInfo->getTypeLoc());
1657
1658  return VisitExpr(E);
1659}
1660
1661bool CursorVisitor::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1662  if (TypeSourceInfo *TSInfo = E->getTypeSourceInfo())
1663    return Visit(TSInfo->getTypeLoc());
1664
1665  return false;
1666}
1667
1668bool CursorVisitor::VisitCXXNewExpr(CXXNewExpr *E) {
1669  // Visit placement arguments.
1670  for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I)
1671    if (Visit(MakeCXCursor(E->getPlacementArg(I), StmtParent, TU)))
1672      return true;
1673
1674  // Visit the allocated type.
1675  if (TypeSourceInfo *TSInfo = E->getAllocatedTypeSourceInfo())
1676    if (Visit(TSInfo->getTypeLoc()))
1677      return true;
1678
1679  // Visit the array size, if any.
1680  if (E->isArray() && Visit(MakeCXCursor(E->getArraySize(), StmtParent, TU)))
1681    return true;
1682
1683  // Visit the initializer or constructor arguments.
1684  for (unsigned I = 0, N = E->getNumConstructorArgs(); I != N; ++I)
1685    if (Visit(MakeCXCursor(E->getConstructorArg(I), StmtParent, TU)))
1686      return true;
1687
1688  return false;
1689}
1690
1691bool CursorVisitor::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1692  // Visit base expression.
1693  if (Visit(MakeCXCursor(E->getBase(), StmtParent, TU)))
1694    return true;
1695
1696  // Visit the nested-name-specifier.
1697  if (NestedNameSpecifier *Qualifier = E->getQualifier())
1698    if (VisitNestedNameSpecifier(Qualifier, E->getQualifierRange()))
1699      return true;
1700
1701  // Visit the scope type that looks disturbingly like the nested-name-specifier
1702  // but isn't.
1703  if (TypeSourceInfo *TSInfo = E->getScopeTypeInfo())
1704    if (Visit(TSInfo->getTypeLoc()))
1705      return true;
1706
1707  // Visit the name of the type being destroyed.
1708  if (TypeSourceInfo *TSInfo = E->getDestroyedTypeInfo())
1709    if (Visit(TSInfo->getTypeLoc()))
1710      return true;
1711
1712  return false;
1713}
1714
1715bool CursorVisitor::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1716  return Visit(E->getQueriedTypeSourceInfo()->getTypeLoc());
1717}
1718
1719bool CursorVisitor::VisitOverloadExpr(OverloadExpr *E) {
1720  // Visit the nested-name-specifier.
1721  if (NestedNameSpecifier *Qualifier = E->getQualifier())
1722    if (VisitNestedNameSpecifier(Qualifier, E->getQualifierRange()))
1723      return true;
1724
1725  // Visit the declaration name.
1726  if (VisitDeclarationNameInfo(E->getNameInfo()))
1727    return true;
1728
1729  // Visit the explicitly-specified template arguments.
1730  if (const ExplicitTemplateArgumentList *ArgList
1731                                      = E->getOptionalExplicitTemplateArgs()) {
1732    for (const TemplateArgumentLoc *Arg = ArgList->getTemplateArgs(),
1733                                *ArgEnd = Arg + ArgList->NumTemplateArgs;
1734         Arg != ArgEnd; ++Arg) {
1735      if (VisitTemplateArgumentLoc(*Arg))
1736        return true;
1737    }
1738  }
1739
1740  // FIXME: We don't have a way to visit all of the declarations referenced
1741  // here.
1742  return false;
1743}
1744
1745bool CursorVisitor::VisitDependentScopeDeclRefExpr(
1746                                                DependentScopeDeclRefExpr *E) {
1747  // Visit the nested-name-specifier.
1748  if (NestedNameSpecifier *Qualifier = E->getQualifier())
1749    if (VisitNestedNameSpecifier(Qualifier, E->getQualifierRange()))
1750      return true;
1751
1752  // Visit the declaration name.
1753  if (VisitDeclarationNameInfo(E->getNameInfo()))
1754    return true;
1755
1756  // Visit the explicitly-specified template arguments.
1757  if (const ExplicitTemplateArgumentList *ArgList
1758      = E->getOptionalExplicitTemplateArgs()) {
1759    for (const TemplateArgumentLoc *Arg = ArgList->getTemplateArgs(),
1760         *ArgEnd = Arg + ArgList->NumTemplateArgs;
1761         Arg != ArgEnd; ++Arg) {
1762      if (VisitTemplateArgumentLoc(*Arg))
1763        return true;
1764    }
1765  }
1766
1767  return false;
1768}
1769
1770bool CursorVisitor::VisitCXXUnresolvedConstructExpr(
1771                                                CXXUnresolvedConstructExpr *E) {
1772  if (TypeSourceInfo *TSInfo = E->getTypeSourceInfo())
1773    if (Visit(TSInfo->getTypeLoc()))
1774      return true;
1775
1776  return VisitExpr(E);
1777}
1778
1779bool CursorVisitor::VisitCXXDependentScopeMemberExpr(
1780                                              CXXDependentScopeMemberExpr *E) {
1781  // Visit the base expression, if there is one.
1782  if (!E->isImplicitAccess() &&
1783      Visit(MakeCXCursor(E->getBase(), StmtParent, TU)))
1784    return true;
1785
1786  // Visit the nested-name-specifier.
1787  if (NestedNameSpecifier *Qualifier = E->getQualifier())
1788    if (VisitNestedNameSpecifier(Qualifier, E->getQualifierRange()))
1789      return true;
1790
1791  // Visit the declaration name.
1792  if (VisitDeclarationNameInfo(E->getMemberNameInfo()))
1793    return true;
1794
1795  // Visit the explicitly-specified template arguments.
1796  if (const ExplicitTemplateArgumentList *ArgList
1797      = E->getOptionalExplicitTemplateArgs()) {
1798    for (const TemplateArgumentLoc *Arg = ArgList->getTemplateArgs(),
1799         *ArgEnd = Arg + ArgList->NumTemplateArgs;
1800         Arg != ArgEnd; ++Arg) {
1801      if (VisitTemplateArgumentLoc(*Arg))
1802        return true;
1803    }
1804  }
1805
1806  return false;
1807}
1808
1809bool CursorVisitor::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1810  // Visit the base expression, if there is one.
1811  if (!E->isImplicitAccess() &&
1812      Visit(MakeCXCursor(E->getBase(), StmtParent, TU)))
1813    return true;
1814
1815  return VisitOverloadExpr(E);
1816}
1817
1818bool CursorVisitor::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1819  if (TypeSourceInfo *TSInfo = E->getClassReceiverTypeInfo())
1820    if (Visit(TSInfo->getTypeLoc()))
1821      return true;
1822
1823  return VisitExpr(E);
1824}
1825
1826bool CursorVisitor::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1827  return Visit(E->getEncodedTypeSourceInfo()->getTypeLoc());
1828}
1829
1830
1831bool CursorVisitor::VisitAttributes(Decl *D) {
1832  for (AttrVec::const_iterator i = D->attr_begin(), e = D->attr_end();
1833       i != e; ++i)
1834    if (Visit(MakeCXCursor(*i, D, TU)))
1835        return true;
1836
1837  return false;
1838}
1839
1840extern "C" {
1841CXIndex clang_createIndex(int excludeDeclarationsFromPCH,
1842                          int displayDiagnostics) {
1843  // We use crash recovery to make some of our APIs more reliable, implicitly
1844  // enable it.
1845  llvm::CrashRecoveryContext::Enable();
1846
1847  CIndexer *CIdxr = new CIndexer();
1848  if (excludeDeclarationsFromPCH)
1849    CIdxr->setOnlyLocalDecls();
1850  if (displayDiagnostics)
1851    CIdxr->setDisplayDiagnostics();
1852  return CIdxr;
1853}
1854
1855void clang_disposeIndex(CXIndex CIdx) {
1856  if (CIdx)
1857    delete static_cast<CIndexer *>(CIdx);
1858  if (getenv("LIBCLANG_TIMING"))
1859    llvm::TimerGroup::printAll(llvm::errs());
1860}
1861
1862void clang_setUseExternalASTGeneration(CXIndex CIdx, int value) {
1863  if (CIdx) {
1864    CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
1865    CXXIdx->setUseExternalASTGeneration(value);
1866  }
1867}
1868
1869CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx,
1870                                              const char *ast_filename) {
1871  if (!CIdx)
1872    return 0;
1873
1874  CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
1875
1876  llvm::IntrusiveRefCntPtr<Diagnostic> Diags;
1877  return ASTUnit::LoadFromASTFile(ast_filename, Diags,
1878                                  CXXIdx->getOnlyLocalDecls(),
1879                                  0, 0, true);
1880}
1881
1882unsigned clang_defaultEditingTranslationUnitOptions() {
1883  return CXTranslationUnit_PrecompiledPreamble;
1884}
1885
1886CXTranslationUnit
1887clang_createTranslationUnitFromSourceFile(CXIndex CIdx,
1888                                          const char *source_filename,
1889                                          int num_command_line_args,
1890                                          const char * const *command_line_args,
1891                                          unsigned num_unsaved_files,
1892                                          struct CXUnsavedFile *unsaved_files) {
1893  return clang_parseTranslationUnit(CIdx, source_filename,
1894                                    command_line_args, num_command_line_args,
1895                                    unsaved_files, num_unsaved_files,
1896                                 CXTranslationUnit_DetailedPreprocessingRecord);
1897}
1898
1899struct ParseTranslationUnitInfo {
1900  CXIndex CIdx;
1901  const char *source_filename;
1902  const char *const *command_line_args;
1903  int num_command_line_args;
1904  struct CXUnsavedFile *unsaved_files;
1905  unsigned num_unsaved_files;
1906  unsigned options;
1907  CXTranslationUnit result;
1908};
1909static void clang_parseTranslationUnit_Impl(void *UserData) {
1910  ParseTranslationUnitInfo *PTUI =
1911    static_cast<ParseTranslationUnitInfo*>(UserData);
1912  CXIndex CIdx = PTUI->CIdx;
1913  const char *source_filename = PTUI->source_filename;
1914  const char * const *command_line_args = PTUI->command_line_args;
1915  int num_command_line_args = PTUI->num_command_line_args;
1916  struct CXUnsavedFile *unsaved_files = PTUI->unsaved_files;
1917  unsigned num_unsaved_files = PTUI->num_unsaved_files;
1918  unsigned options = PTUI->options;
1919  PTUI->result = 0;
1920
1921  if (!CIdx)
1922    return;
1923
1924  CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx);
1925
1926  bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble;
1927  bool CompleteTranslationUnit
1928    = ((options & CXTranslationUnit_Incomplete) == 0);
1929  bool CacheCodeCompetionResults
1930    = options & CXTranslationUnit_CacheCompletionResults;
1931
1932  // Configure the diagnostics.
1933  DiagnosticOptions DiagOpts;
1934  llvm::IntrusiveRefCntPtr<Diagnostic> Diags;
1935  Diags = CompilerInstance::createDiagnostics(DiagOpts, 0, 0);
1936
1937  llvm::SmallVector<ASTUnit::RemappedFile, 4> RemappedFiles;
1938  for (unsigned I = 0; I != num_unsaved_files; ++I) {
1939    llvm::StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length);
1940    const llvm::MemoryBuffer *Buffer
1941      = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename);
1942    RemappedFiles.push_back(std::make_pair(unsaved_files[I].Filename,
1943                                           Buffer));
1944  }
1945
1946  if (!CXXIdx->getUseExternalASTGeneration()) {
1947    llvm::SmallVector<const char *, 16> Args;
1948
1949    // The 'source_filename' argument is optional.  If the caller does not
1950    // specify it then it is assumed that the source file is specified
1951    // in the actual argument list.
1952    if (source_filename)
1953      Args.push_back(source_filename);
1954
1955    // Since the Clang C library is primarily used by batch tools dealing with
1956    // (often very broken) source code, where spell-checking can have a
1957    // significant negative impact on performance (particularly when
1958    // precompiled headers are involved), we disable it by default.
1959    // Note that we place this argument early in the list, so that it can be
1960    // overridden by the caller with "-fspell-checking".
1961    Args.push_back("-fno-spell-checking");
1962
1963    Args.insert(Args.end(), command_line_args,
1964                command_line_args + num_command_line_args);
1965
1966    // Do we need the detailed preprocessing record?
1967    if (options & CXTranslationUnit_DetailedPreprocessingRecord) {
1968      Args.push_back("-Xclang");
1969      Args.push_back("-detailed-preprocessing-record");
1970    }
1971
1972    unsigned NumErrors = Diags->getNumErrors();
1973
1974#ifdef USE_CRASHTRACER
1975    ArgsCrashTracerInfo ACTI(Args);
1976#endif
1977
1978    llvm::OwningPtr<ASTUnit> Unit(
1979      ASTUnit::LoadFromCommandLine(Args.data(), Args.data() + Args.size(),
1980                                   Diags,
1981                                   CXXIdx->getClangResourcesPath(),
1982                                   CXXIdx->getOnlyLocalDecls(),
1983                                   RemappedFiles.data(),
1984                                   RemappedFiles.size(),
1985                                   /*CaptureDiagnostics=*/true,
1986                                   PrecompilePreamble,
1987                                   CompleteTranslationUnit,
1988                                   CacheCodeCompetionResults));
1989
1990    if (NumErrors != Diags->getNumErrors()) {
1991      // Make sure to check that 'Unit' is non-NULL.
1992      if (CXXIdx->getDisplayDiagnostics() && Unit.get()) {
1993        for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(),
1994                                        DEnd = Unit->stored_diag_end();
1995             D != DEnd; ++D) {
1996          CXStoredDiagnostic Diag(*D, Unit->getASTContext().getLangOptions());
1997          CXString Msg = clang_formatDiagnostic(&Diag,
1998                                      clang_defaultDiagnosticDisplayOptions());
1999          fprintf(stderr, "%s\n", clang_getCString(Msg));
2000          clang_disposeString(Msg);
2001        }
2002#ifdef LLVM_ON_WIN32
2003        // On Windows, force a flush, since there may be multiple copies of
2004        // stderr and stdout in the file system, all with different buffers
2005        // but writing to the same device.
2006        fflush(stderr);
2007#endif
2008      }
2009    }
2010
2011    PTUI->result = Unit.take();
2012    return;
2013  }
2014
2015  // Build up the arguments for invoking 'clang'.
2016  std::vector<const char *> argv;
2017
2018  // First add the complete path to the 'clang' executable.
2019  llvm::sys::Path ClangPath = static_cast<CIndexer *>(CIdx)->getClangPath();
2020  argv.push_back(ClangPath.c_str());
2021
2022  // Add the '-emit-ast' option as our execution mode for 'clang'.
2023  argv.push_back("-emit-ast");
2024
2025  // The 'source_filename' argument is optional.  If the caller does not
2026  // specify it then it is assumed that the source file is specified
2027  // in the actual argument list.
2028  if (source_filename)
2029    argv.push_back(source_filename);
2030
2031  // Generate a temporary name for the AST file.
2032  argv.push_back("-o");
2033  char astTmpFile[L_tmpnam];
2034  argv.push_back(tmpnam(astTmpFile));
2035
2036  // Since the Clang C library is primarily used by batch tools dealing with
2037  // (often very broken) source code, where spell-checking can have a
2038  // significant negative impact on performance (particularly when
2039  // precompiled headers are involved), we disable it by default.
2040  // Note that we place this argument early in the list, so that it can be
2041  // overridden by the caller with "-fspell-checking".
2042  argv.push_back("-fno-spell-checking");
2043
2044  // Remap any unsaved files to temporary files.
2045  std::vector<llvm::sys::Path> TemporaryFiles;
2046  std::vector<std::string> RemapArgs;
2047  if (RemapFiles(num_unsaved_files, unsaved_files, RemapArgs, TemporaryFiles))
2048    return;
2049
2050  // The pointers into the elements of RemapArgs are stable because we
2051  // won't be adding anything to RemapArgs after this point.
2052  for (unsigned i = 0, e = RemapArgs.size(); i != e; ++i)
2053    argv.push_back(RemapArgs[i].c_str());
2054
2055  // Process the compiler options, stripping off '-o', '-c', '-fsyntax-only'.
2056  for (int i = 0; i < num_command_line_args; ++i)
2057    if (const char *arg = command_line_args[i]) {
2058      if (strcmp(arg, "-o") == 0) {
2059        ++i; // Also skip the matching argument.
2060        continue;
2061      }
2062      if (strcmp(arg, "-emit-ast") == 0 ||
2063          strcmp(arg, "-c") == 0 ||
2064          strcmp(arg, "-fsyntax-only") == 0) {
2065        continue;
2066      }
2067
2068      // Keep the argument.
2069      argv.push_back(arg);
2070    }
2071
2072  // Generate a temporary name for the diagnostics file.
2073  char tmpFileResults[L_tmpnam];
2074  char *tmpResultsFileName = tmpnam(tmpFileResults);
2075  llvm::sys::Path DiagnosticsFile(tmpResultsFileName);
2076  TemporaryFiles.push_back(DiagnosticsFile);
2077  argv.push_back("-fdiagnostics-binary");
2078
2079  // Do we need the detailed preprocessing record?
2080  if (options & CXTranslationUnit_DetailedPreprocessingRecord) {
2081    argv.push_back("-Xclang");
2082    argv.push_back("-detailed-preprocessing-record");
2083  }
2084
2085  // Add the null terminator.
2086  argv.push_back(NULL);
2087
2088  // Invoke 'clang'.
2089  llvm::sys::Path DevNull; // leave empty, causes redirection to /dev/null
2090                           // on Unix or NUL (Windows).
2091  std::string ErrMsg;
2092  const llvm::sys::Path *Redirects[] = { &DevNull, &DevNull, &DiagnosticsFile,
2093                                         NULL };
2094  llvm::sys::Program::ExecuteAndWait(ClangPath, &argv[0], /* env */ NULL,
2095      /* redirects */ &Redirects[0],
2096      /* secondsToWait */ 0, /* memoryLimits */ 0, &ErrMsg);
2097
2098  if (!ErrMsg.empty()) {
2099    std::string AllArgs;
2100    for (std::vector<const char*>::iterator I = argv.begin(), E = argv.end();
2101         I != E; ++I) {
2102      AllArgs += ' ';
2103      if (*I)
2104        AllArgs += *I;
2105    }
2106
2107    Diags->Report(diag::err_fe_invoking) << AllArgs << ErrMsg;
2108  }
2109
2110  ASTUnit *ATU = ASTUnit::LoadFromASTFile(astTmpFile, Diags,
2111                                          CXXIdx->getOnlyLocalDecls(),
2112                                          RemappedFiles.data(),
2113                                          RemappedFiles.size(),
2114                                          /*CaptureDiagnostics=*/true);
2115  if (ATU) {
2116    LoadSerializedDiagnostics(DiagnosticsFile,
2117                              num_unsaved_files, unsaved_files,
2118                              ATU->getFileManager(),
2119                              ATU->getSourceManager(),
2120                              ATU->getStoredDiagnostics());
2121  } else if (CXXIdx->getDisplayDiagnostics()) {
2122    // We failed to load the ASTUnit, but we can still deserialize the
2123    // diagnostics and emit them.
2124    FileManager FileMgr;
2125    Diagnostic Diag;
2126    SourceManager SourceMgr(Diag);
2127    // FIXME: Faked LangOpts!
2128    LangOptions LangOpts;
2129    llvm::SmallVector<StoredDiagnostic, 4> Diags;
2130    LoadSerializedDiagnostics(DiagnosticsFile,
2131                              num_unsaved_files, unsaved_files,
2132                              FileMgr, SourceMgr, Diags);
2133    for (llvm::SmallVector<StoredDiagnostic, 4>::iterator D = Diags.begin(),
2134                                                       DEnd = Diags.end();
2135         D != DEnd; ++D) {
2136      CXStoredDiagnostic Diag(*D, LangOpts);
2137      CXString Msg = clang_formatDiagnostic(&Diag,
2138                                      clang_defaultDiagnosticDisplayOptions());
2139      fprintf(stderr, "%s\n", clang_getCString(Msg));
2140      clang_disposeString(Msg);
2141    }
2142
2143#ifdef LLVM_ON_WIN32
2144    // On Windows, force a flush, since there may be multiple copies of
2145    // stderr and stdout in the file system, all with different buffers
2146    // but writing to the same device.
2147    fflush(stderr);
2148#endif
2149  }
2150
2151  if (ATU) {
2152    // Make the translation unit responsible for destroying all temporary files.
2153    for (unsigned i = 0, e = TemporaryFiles.size(); i != e; ++i)
2154      ATU->addTemporaryFile(TemporaryFiles[i]);
2155    ATU->addTemporaryFile(llvm::sys::Path(ATU->getASTFileName()));
2156  } else {
2157    // Destroy all of the temporary files now; they can't be referenced any
2158    // longer.
2159    llvm::sys::Path(astTmpFile).eraseFromDisk();
2160    for (unsigned i = 0, e = TemporaryFiles.size(); i != e; ++i)
2161      TemporaryFiles[i].eraseFromDisk();
2162  }
2163
2164  PTUI->result = ATU;
2165}
2166CXTranslationUnit clang_parseTranslationUnit(CXIndex CIdx,
2167                                             const char *source_filename,
2168                                         const char * const *command_line_args,
2169                                             int num_command_line_args,
2170                                             struct CXUnsavedFile *unsaved_files,
2171                                             unsigned num_unsaved_files,
2172                                             unsigned options) {
2173  ParseTranslationUnitInfo PTUI = { CIdx, source_filename, command_line_args,
2174                                    num_command_line_args, unsaved_files, num_unsaved_files,
2175                                    options, 0 };
2176  llvm::CrashRecoveryContext CRC;
2177
2178  if (!CRC.RunSafely(clang_parseTranslationUnit_Impl, &PTUI)) {
2179    fprintf(stderr, "libclang: crash detected during parsing: {\n");
2180    fprintf(stderr, "  'source_filename' : '%s'\n", source_filename);
2181    fprintf(stderr, "  'command_line_args' : [");
2182    for (int i = 0; i != num_command_line_args; ++i) {
2183      if (i)
2184        fprintf(stderr, ", ");
2185      fprintf(stderr, "'%s'", command_line_args[i]);
2186    }
2187    fprintf(stderr, "],\n");
2188    fprintf(stderr, "  'unsaved_files' : [");
2189    for (unsigned i = 0; i != num_unsaved_files; ++i) {
2190      if (i)
2191        fprintf(stderr, ", ");
2192      fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename,
2193              unsaved_files[i].Length);
2194    }
2195    fprintf(stderr, "],\n");
2196    fprintf(stderr, "  'options' : %d,\n", options);
2197    fprintf(stderr, "}\n");
2198
2199    return 0;
2200  }
2201
2202  return PTUI.result;
2203}
2204
2205unsigned clang_defaultSaveOptions(CXTranslationUnit TU) {
2206  return CXSaveTranslationUnit_None;
2207}
2208
2209int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName,
2210                              unsigned options) {
2211  if (!TU)
2212    return 1;
2213
2214  return static_cast<ASTUnit *>(TU)->Save(FileName);
2215}
2216
2217void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) {
2218  if (CTUnit) {
2219    // If the translation unit has been marked as unsafe to free, just discard
2220    // it.
2221    if (static_cast<ASTUnit *>(CTUnit)->isUnsafeToFree())
2222      return;
2223
2224    delete static_cast<ASTUnit *>(CTUnit);
2225  }
2226}
2227
2228unsigned clang_defaultReparseOptions(CXTranslationUnit TU) {
2229  return CXReparse_None;
2230}
2231
2232struct ReparseTranslationUnitInfo {
2233  CXTranslationUnit TU;
2234  unsigned num_unsaved_files;
2235  struct CXUnsavedFile *unsaved_files;
2236  unsigned options;
2237  int result;
2238};
2239static void clang_reparseTranslationUnit_Impl(void *UserData) {
2240  ReparseTranslationUnitInfo *RTUI =
2241    static_cast<ReparseTranslationUnitInfo*>(UserData);
2242  CXTranslationUnit TU = RTUI->TU;
2243  unsigned num_unsaved_files = RTUI->num_unsaved_files;
2244  struct CXUnsavedFile *unsaved_files = RTUI->unsaved_files;
2245  unsigned options = RTUI->options;
2246  (void) options;
2247  RTUI->result = 1;
2248
2249  if (!TU)
2250    return;
2251
2252  llvm::SmallVector<ASTUnit::RemappedFile, 4> RemappedFiles;
2253  for (unsigned I = 0; I != num_unsaved_files; ++I) {
2254    llvm::StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length);
2255    const llvm::MemoryBuffer *Buffer
2256      = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename);
2257    RemappedFiles.push_back(std::make_pair(unsaved_files[I].Filename,
2258                                           Buffer));
2259  }
2260
2261  if (!static_cast<ASTUnit *>(TU)->Reparse(RemappedFiles.data(),
2262                                           RemappedFiles.size()))
2263      RTUI->result = 0;
2264}
2265int clang_reparseTranslationUnit(CXTranslationUnit TU,
2266                                 unsigned num_unsaved_files,
2267                                 struct CXUnsavedFile *unsaved_files,
2268                                 unsigned options) {
2269  ReparseTranslationUnitInfo RTUI = { TU, num_unsaved_files, unsaved_files,
2270                                      options, 0 };
2271  llvm::CrashRecoveryContext CRC;
2272
2273  if (!CRC.RunSafely(clang_reparseTranslationUnit_Impl, &RTUI)) {
2274    fprintf(stderr, "libclang: crash detected during reparsing\n");
2275    static_cast<ASTUnit *>(TU)->setUnsafeToFree(true);
2276    return 1;
2277  }
2278
2279  return RTUI.result;
2280}
2281
2282
2283CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) {
2284  if (!CTUnit)
2285    return createCXString("");
2286
2287  ASTUnit *CXXUnit = static_cast<ASTUnit *>(CTUnit);
2288  return createCXString(CXXUnit->getOriginalSourceFileName(), true);
2289}
2290
2291CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) {
2292  CXCursor Result = { CXCursor_TranslationUnit, { 0, 0, TU } };
2293  return Result;
2294}
2295
2296} // end: extern "C"
2297
2298//===----------------------------------------------------------------------===//
2299// CXSourceLocation and CXSourceRange Operations.
2300//===----------------------------------------------------------------------===//
2301
2302extern "C" {
2303CXSourceLocation clang_getNullLocation() {
2304  CXSourceLocation Result = { { 0, 0 }, 0 };
2305  return Result;
2306}
2307
2308unsigned clang_equalLocations(CXSourceLocation loc1, CXSourceLocation loc2) {
2309  return (loc1.ptr_data[0] == loc2.ptr_data[0] &&
2310          loc1.ptr_data[1] == loc2.ptr_data[1] &&
2311          loc1.int_data == loc2.int_data);
2312}
2313
2314CXSourceLocation clang_getLocation(CXTranslationUnit tu,
2315                                   CXFile file,
2316                                   unsigned line,
2317                                   unsigned column) {
2318  if (!tu || !file)
2319    return clang_getNullLocation();
2320
2321  ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu);
2322  SourceLocation SLoc
2323    = CXXUnit->getSourceManager().getLocation(
2324                                        static_cast<const FileEntry *>(file),
2325                                              line, column);
2326
2327  return cxloc::translateSourceLocation(CXXUnit->getASTContext(), SLoc);
2328}
2329
2330CXSourceRange clang_getNullRange() {
2331  CXSourceRange Result = { { 0, 0 }, 0, 0 };
2332  return Result;
2333}
2334
2335CXSourceRange clang_getRange(CXSourceLocation begin, CXSourceLocation end) {
2336  if (begin.ptr_data[0] != end.ptr_data[0] ||
2337      begin.ptr_data[1] != end.ptr_data[1])
2338    return clang_getNullRange();
2339
2340  CXSourceRange Result = { { begin.ptr_data[0], begin.ptr_data[1] },
2341                           begin.int_data, end.int_data };
2342  return Result;
2343}
2344
2345void clang_getInstantiationLocation(CXSourceLocation location,
2346                                    CXFile *file,
2347                                    unsigned *line,
2348                                    unsigned *column,
2349                                    unsigned *offset) {
2350  SourceLocation Loc = SourceLocation::getFromRawEncoding(location.int_data);
2351
2352  if (!location.ptr_data[0] || Loc.isInvalid()) {
2353    if (file)
2354      *file = 0;
2355    if (line)
2356      *line = 0;
2357    if (column)
2358      *column = 0;
2359    if (offset)
2360      *offset = 0;
2361    return;
2362  }
2363
2364  const SourceManager &SM =
2365    *static_cast<const SourceManager*>(location.ptr_data[0]);
2366  SourceLocation InstLoc = SM.getInstantiationLoc(Loc);
2367
2368  if (file)
2369    *file = (void *)SM.getFileEntryForID(SM.getFileID(InstLoc));
2370  if (line)
2371    *line = SM.getInstantiationLineNumber(InstLoc);
2372  if (column)
2373    *column = SM.getInstantiationColumnNumber(InstLoc);
2374  if (offset)
2375    *offset = SM.getDecomposedLoc(InstLoc).second;
2376}
2377
2378CXSourceLocation clang_getRangeStart(CXSourceRange range) {
2379  CXSourceLocation Result = { { range.ptr_data[0], range.ptr_data[1] },
2380                              range.begin_int_data };
2381  return Result;
2382}
2383
2384CXSourceLocation clang_getRangeEnd(CXSourceRange range) {
2385  CXSourceLocation Result = { { range.ptr_data[0], range.ptr_data[1] },
2386                              range.end_int_data };
2387  return Result;
2388}
2389
2390} // end: extern "C"
2391
2392//===----------------------------------------------------------------------===//
2393// CXFile Operations.
2394//===----------------------------------------------------------------------===//
2395
2396extern "C" {
2397CXString clang_getFileName(CXFile SFile) {
2398  if (!SFile)
2399    return createCXString(NULL);
2400
2401  FileEntry *FEnt = static_cast<FileEntry *>(SFile);
2402  return createCXString(FEnt->getName());
2403}
2404
2405time_t clang_getFileTime(CXFile SFile) {
2406  if (!SFile)
2407    return 0;
2408
2409  FileEntry *FEnt = static_cast<FileEntry *>(SFile);
2410  return FEnt->getModificationTime();
2411}
2412
2413CXFile clang_getFile(CXTranslationUnit tu, const char *file_name) {
2414  if (!tu)
2415    return 0;
2416
2417  ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu);
2418
2419  FileManager &FMgr = CXXUnit->getFileManager();
2420  const FileEntry *File = FMgr.getFile(file_name, file_name+strlen(file_name));
2421  return const_cast<FileEntry *>(File);
2422}
2423
2424} // end: extern "C"
2425
2426//===----------------------------------------------------------------------===//
2427// CXCursor Operations.
2428//===----------------------------------------------------------------------===//
2429
2430static Decl *getDeclFromExpr(Stmt *E) {
2431  if (DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E))
2432    return RefExpr->getDecl();
2433  if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
2434    return ME->getMemberDecl();
2435  if (ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E))
2436    return RE->getDecl();
2437
2438  if (CallExpr *CE = dyn_cast<CallExpr>(E))
2439    return getDeclFromExpr(CE->getCallee());
2440  if (CastExpr *CE = dyn_cast<CastExpr>(E))
2441    return getDeclFromExpr(CE->getSubExpr());
2442  if (ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E))
2443    return OME->getMethodDecl();
2444
2445  return 0;
2446}
2447
2448static SourceLocation getLocationFromExpr(Expr *E) {
2449  if (ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E))
2450    return /*FIXME:*/Msg->getLeftLoc();
2451  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
2452    return DRE->getLocation();
2453  if (MemberExpr *Member = dyn_cast<MemberExpr>(E))
2454    return Member->getMemberLoc();
2455  if (ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E))
2456    return Ivar->getLocation();
2457  return E->getLocStart();
2458}
2459
2460extern "C" {
2461
2462unsigned clang_visitChildren(CXCursor parent,
2463                             CXCursorVisitor visitor,
2464                             CXClientData client_data) {
2465  ASTUnit *CXXUnit = getCursorASTUnit(parent);
2466
2467  CursorVisitor CursorVis(CXXUnit, visitor, client_data,
2468                          CXXUnit->getMaxPCHLevel());
2469  return CursorVis.VisitChildren(parent);
2470}
2471
2472static CXString getDeclSpelling(Decl *D) {
2473  NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D);
2474  if (!ND)
2475    return createCXString("");
2476
2477  if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
2478    return createCXString(OMD->getSelector().getAsString());
2479
2480  if (ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND))
2481    // No, this isn't the same as the code below. getIdentifier() is non-virtual
2482    // and returns different names. NamedDecl returns the class name and
2483    // ObjCCategoryImplDecl returns the category name.
2484    return createCXString(CIMP->getIdentifier()->getNameStart());
2485
2486  if (isa<UsingDirectiveDecl>(D))
2487    return createCXString("");
2488
2489  llvm::SmallString<1024> S;
2490  llvm::raw_svector_ostream os(S);
2491  ND->printName(os);
2492
2493  return createCXString(os.str());
2494}
2495
2496CXString clang_getCursorSpelling(CXCursor C) {
2497  if (clang_isTranslationUnit(C.kind))
2498    return clang_getTranslationUnitSpelling(C.data[2]);
2499
2500  if (clang_isReference(C.kind)) {
2501    switch (C.kind) {
2502    case CXCursor_ObjCSuperClassRef: {
2503      ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first;
2504      return createCXString(Super->getIdentifier()->getNameStart());
2505    }
2506    case CXCursor_ObjCClassRef: {
2507      ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
2508      return createCXString(Class->getIdentifier()->getNameStart());
2509    }
2510    case CXCursor_ObjCProtocolRef: {
2511      ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first;
2512      assert(OID && "getCursorSpelling(): Missing protocol decl");
2513      return createCXString(OID->getIdentifier()->getNameStart());
2514    }
2515    case CXCursor_CXXBaseSpecifier: {
2516      CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C);
2517      return createCXString(B->getType().getAsString());
2518    }
2519    case CXCursor_TypeRef: {
2520      TypeDecl *Type = getCursorTypeRef(C).first;
2521      assert(Type && "Missing type decl");
2522
2523      return createCXString(getCursorContext(C).getTypeDeclType(Type).
2524                              getAsString());
2525    }
2526    case CXCursor_TemplateRef: {
2527      TemplateDecl *Template = getCursorTemplateRef(C).first;
2528      assert(Template && "Missing template decl");
2529
2530      return createCXString(Template->getNameAsString());
2531    }
2532
2533    case CXCursor_NamespaceRef: {
2534      NamedDecl *NS = getCursorNamespaceRef(C).first;
2535      assert(NS && "Missing namespace decl");
2536
2537      return createCXString(NS->getNameAsString());
2538    }
2539
2540    case CXCursor_MemberRef: {
2541      FieldDecl *Field = getCursorMemberRef(C).first;
2542      assert(Field && "Missing member decl");
2543
2544      return createCXString(Field->getNameAsString());
2545    }
2546
2547    default:
2548      return createCXString("<not implemented>");
2549    }
2550  }
2551
2552  if (clang_isExpression(C.kind)) {
2553    Decl *D = getDeclFromExpr(getCursorExpr(C));
2554    if (D)
2555      return getDeclSpelling(D);
2556    return createCXString("");
2557  }
2558
2559  if (C.kind == CXCursor_MacroInstantiation)
2560    return createCXString(getCursorMacroInstantiation(C)->getName()
2561                                                           ->getNameStart());
2562
2563  if (C.kind == CXCursor_MacroDefinition)
2564    return createCXString(getCursorMacroDefinition(C)->getName()
2565                                                           ->getNameStart());
2566
2567  if (clang_isDeclaration(C.kind))
2568    return getDeclSpelling(getCursorDecl(C));
2569
2570  return createCXString("");
2571}
2572
2573CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
2574  switch (Kind) {
2575  case CXCursor_FunctionDecl:
2576      return createCXString("FunctionDecl");
2577  case CXCursor_TypedefDecl:
2578      return createCXString("TypedefDecl");
2579  case CXCursor_EnumDecl:
2580      return createCXString("EnumDecl");
2581  case CXCursor_EnumConstantDecl:
2582      return createCXString("EnumConstantDecl");
2583  case CXCursor_StructDecl:
2584      return createCXString("StructDecl");
2585  case CXCursor_UnionDecl:
2586      return createCXString("UnionDecl");
2587  case CXCursor_ClassDecl:
2588      return createCXString("ClassDecl");
2589  case CXCursor_FieldDecl:
2590      return createCXString("FieldDecl");
2591  case CXCursor_VarDecl:
2592      return createCXString("VarDecl");
2593  case CXCursor_ParmDecl:
2594      return createCXString("ParmDecl");
2595  case CXCursor_ObjCInterfaceDecl:
2596      return createCXString("ObjCInterfaceDecl");
2597  case CXCursor_ObjCCategoryDecl:
2598      return createCXString("ObjCCategoryDecl");
2599  case CXCursor_ObjCProtocolDecl:
2600      return createCXString("ObjCProtocolDecl");
2601  case CXCursor_ObjCPropertyDecl:
2602      return createCXString("ObjCPropertyDecl");
2603  case CXCursor_ObjCIvarDecl:
2604      return createCXString("ObjCIvarDecl");
2605  case CXCursor_ObjCInstanceMethodDecl:
2606      return createCXString("ObjCInstanceMethodDecl");
2607  case CXCursor_ObjCClassMethodDecl:
2608      return createCXString("ObjCClassMethodDecl");
2609  case CXCursor_ObjCImplementationDecl:
2610      return createCXString("ObjCImplementationDecl");
2611  case CXCursor_ObjCCategoryImplDecl:
2612      return createCXString("ObjCCategoryImplDecl");
2613  case CXCursor_CXXMethod:
2614      return createCXString("CXXMethod");
2615  case CXCursor_UnexposedDecl:
2616      return createCXString("UnexposedDecl");
2617  case CXCursor_ObjCSuperClassRef:
2618      return createCXString("ObjCSuperClassRef");
2619  case CXCursor_ObjCProtocolRef:
2620      return createCXString("ObjCProtocolRef");
2621  case CXCursor_ObjCClassRef:
2622      return createCXString("ObjCClassRef");
2623  case CXCursor_TypeRef:
2624      return createCXString("TypeRef");
2625  case CXCursor_TemplateRef:
2626      return createCXString("TemplateRef");
2627  case CXCursor_NamespaceRef:
2628    return createCXString("NamespaceRef");
2629  case CXCursor_MemberRef:
2630    return createCXString("MemberRef");
2631  case CXCursor_UnexposedExpr:
2632      return createCXString("UnexposedExpr");
2633  case CXCursor_BlockExpr:
2634      return createCXString("BlockExpr");
2635  case CXCursor_DeclRefExpr:
2636      return createCXString("DeclRefExpr");
2637  case CXCursor_MemberRefExpr:
2638      return createCXString("MemberRefExpr");
2639  case CXCursor_CallExpr:
2640      return createCXString("CallExpr");
2641  case CXCursor_ObjCMessageExpr:
2642      return createCXString("ObjCMessageExpr");
2643  case CXCursor_UnexposedStmt:
2644      return createCXString("UnexposedStmt");
2645  case CXCursor_InvalidFile:
2646      return createCXString("InvalidFile");
2647  case CXCursor_InvalidCode:
2648    return createCXString("InvalidCode");
2649  case CXCursor_NoDeclFound:
2650      return createCXString("NoDeclFound");
2651  case CXCursor_NotImplemented:
2652      return createCXString("NotImplemented");
2653  case CXCursor_TranslationUnit:
2654      return createCXString("TranslationUnit");
2655  case CXCursor_UnexposedAttr:
2656      return createCXString("UnexposedAttr");
2657  case CXCursor_IBActionAttr:
2658      return createCXString("attribute(ibaction)");
2659  case CXCursor_IBOutletAttr:
2660     return createCXString("attribute(iboutlet)");
2661  case CXCursor_IBOutletCollectionAttr:
2662      return createCXString("attribute(iboutletcollection)");
2663  case CXCursor_PreprocessingDirective:
2664    return createCXString("preprocessing directive");
2665  case CXCursor_MacroDefinition:
2666    return createCXString("macro definition");
2667  case CXCursor_MacroInstantiation:
2668    return createCXString("macro instantiation");
2669  case CXCursor_Namespace:
2670    return createCXString("Namespace");
2671  case CXCursor_LinkageSpec:
2672    return createCXString("LinkageSpec");
2673  case CXCursor_CXXBaseSpecifier:
2674    return createCXString("C++ base class specifier");
2675  case CXCursor_Constructor:
2676    return createCXString("CXXConstructor");
2677  case CXCursor_Destructor:
2678    return createCXString("CXXDestructor");
2679  case CXCursor_ConversionFunction:
2680    return createCXString("CXXConversion");
2681  case CXCursor_TemplateTypeParameter:
2682    return createCXString("TemplateTypeParameter");
2683  case CXCursor_NonTypeTemplateParameter:
2684    return createCXString("NonTypeTemplateParameter");
2685  case CXCursor_TemplateTemplateParameter:
2686    return createCXString("TemplateTemplateParameter");
2687  case CXCursor_FunctionTemplate:
2688    return createCXString("FunctionTemplate");
2689  case CXCursor_ClassTemplate:
2690    return createCXString("ClassTemplate");
2691  case CXCursor_ClassTemplatePartialSpecialization:
2692    return createCXString("ClassTemplatePartialSpecialization");
2693  case CXCursor_NamespaceAlias:
2694    return createCXString("NamespaceAlias");
2695  case CXCursor_UsingDirective:
2696    return createCXString("UsingDirective");
2697  case CXCursor_UsingDeclaration:
2698    return createCXString("UsingDeclaration");
2699  }
2700
2701  llvm_unreachable("Unhandled CXCursorKind");
2702  return createCXString(NULL);
2703}
2704
2705enum CXChildVisitResult GetCursorVisitor(CXCursor cursor,
2706                                         CXCursor parent,
2707                                         CXClientData client_data) {
2708  CXCursor *BestCursor = static_cast<CXCursor *>(client_data);
2709  *BestCursor = cursor;
2710  return CXChildVisit_Recurse;
2711}
2712
2713CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) {
2714  if (!TU)
2715    return clang_getNullCursor();
2716
2717  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU);
2718  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
2719
2720  // Translate the given source location to make it point at the beginning of
2721  // the token under the cursor.
2722  SourceLocation SLoc = cxloc::translateSourceLocation(Loc);
2723
2724  // Guard against an invalid SourceLocation, or we may assert in one
2725  // of the following calls.
2726  if (SLoc.isInvalid())
2727    return clang_getNullCursor();
2728
2729  SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(),
2730                                    CXXUnit->getASTContext().getLangOptions());
2731
2732  CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound);
2733  if (SLoc.isValid()) {
2734    // FIXME: Would be great to have a "hint" cursor, then walk from that
2735    // hint cursor upward until we find a cursor whose source range encloses
2736    // the region of interest, rather than starting from the translation unit.
2737    CXCursor Parent = clang_getTranslationUnitCursor(CXXUnit);
2738    CursorVisitor CursorVis(CXXUnit, GetCursorVisitor, &Result,
2739                            Decl::MaxPCHLevel, SourceLocation(SLoc));
2740    CursorVis.VisitChildren(Parent);
2741  }
2742  return Result;
2743}
2744
2745CXCursor clang_getNullCursor(void) {
2746  return MakeCXCursorInvalid(CXCursor_InvalidFile);
2747}
2748
2749unsigned clang_equalCursors(CXCursor X, CXCursor Y) {
2750  return X == Y;
2751}
2752
2753unsigned clang_isInvalid(enum CXCursorKind K) {
2754  return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid;
2755}
2756
2757unsigned clang_isDeclaration(enum CXCursorKind K) {
2758  return K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl;
2759}
2760
2761unsigned clang_isReference(enum CXCursorKind K) {
2762  return K >= CXCursor_FirstRef && K <= CXCursor_LastRef;
2763}
2764
2765unsigned clang_isExpression(enum CXCursorKind K) {
2766  return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr;
2767}
2768
2769unsigned clang_isStatement(enum CXCursorKind K) {
2770  return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt;
2771}
2772
2773unsigned clang_isTranslationUnit(enum CXCursorKind K) {
2774  return K == CXCursor_TranslationUnit;
2775}
2776
2777unsigned clang_isPreprocessing(enum CXCursorKind K) {
2778  return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing;
2779}
2780
2781unsigned clang_isUnexposed(enum CXCursorKind K) {
2782  switch (K) {
2783    case CXCursor_UnexposedDecl:
2784    case CXCursor_UnexposedExpr:
2785    case CXCursor_UnexposedStmt:
2786    case CXCursor_UnexposedAttr:
2787      return true;
2788    default:
2789      return false;
2790  }
2791}
2792
2793CXCursorKind clang_getCursorKind(CXCursor C) {
2794  return C.kind;
2795}
2796
2797CXSourceLocation clang_getCursorLocation(CXCursor C) {
2798  if (clang_isReference(C.kind)) {
2799    switch (C.kind) {
2800    case CXCursor_ObjCSuperClassRef: {
2801      std::pair<ObjCInterfaceDecl *, SourceLocation> P
2802        = getCursorObjCSuperClassRef(C);
2803      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
2804    }
2805
2806    case CXCursor_ObjCProtocolRef: {
2807      std::pair<ObjCProtocolDecl *, SourceLocation> P
2808        = getCursorObjCProtocolRef(C);
2809      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
2810    }
2811
2812    case CXCursor_ObjCClassRef: {
2813      std::pair<ObjCInterfaceDecl *, SourceLocation> P
2814        = getCursorObjCClassRef(C);
2815      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
2816    }
2817
2818    case CXCursor_TypeRef: {
2819      std::pair<TypeDecl *, SourceLocation> P = getCursorTypeRef(C);
2820      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
2821    }
2822
2823    case CXCursor_TemplateRef: {
2824      std::pair<TemplateDecl *, SourceLocation> P = getCursorTemplateRef(C);
2825      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
2826    }
2827
2828    case CXCursor_NamespaceRef: {
2829      std::pair<NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C);
2830      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
2831    }
2832
2833    case CXCursor_MemberRef: {
2834      std::pair<FieldDecl *, SourceLocation> P = getCursorMemberRef(C);
2835      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
2836    }
2837
2838    case CXCursor_CXXBaseSpecifier: {
2839      // FIXME: Figure out what location to return for a CXXBaseSpecifier.
2840      return clang_getNullLocation();
2841    }
2842
2843    default:
2844      // FIXME: Need a way to enumerate all non-reference cases.
2845      llvm_unreachable("Missed a reference kind");
2846    }
2847  }
2848
2849  if (clang_isExpression(C.kind))
2850    return cxloc::translateSourceLocation(getCursorContext(C),
2851                                   getLocationFromExpr(getCursorExpr(C)));
2852
2853  if (C.kind == CXCursor_PreprocessingDirective) {
2854    SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin();
2855    return cxloc::translateSourceLocation(getCursorContext(C), L);
2856  }
2857
2858  if (C.kind == CXCursor_MacroInstantiation) {
2859    SourceLocation L
2860      = cxcursor::getCursorMacroInstantiation(C)->getSourceRange().getBegin();
2861    return cxloc::translateSourceLocation(getCursorContext(C), L);
2862  }
2863
2864  if (C.kind == CXCursor_MacroDefinition) {
2865    SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation();
2866    return cxloc::translateSourceLocation(getCursorContext(C), L);
2867  }
2868
2869  if (C.kind < CXCursor_FirstDecl || C.kind > CXCursor_LastDecl)
2870    return clang_getNullLocation();
2871
2872  Decl *D = getCursorDecl(C);
2873  SourceLocation Loc = D->getLocation();
2874  if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
2875    Loc = Class->getClassLoc();
2876  return cxloc::translateSourceLocation(getCursorContext(C), Loc);
2877}
2878
2879} // end extern "C"
2880
2881static SourceRange getRawCursorExtent(CXCursor C) {
2882  if (clang_isReference(C.kind)) {
2883    switch (C.kind) {
2884    case CXCursor_ObjCSuperClassRef:
2885      return  getCursorObjCSuperClassRef(C).second;
2886
2887    case CXCursor_ObjCProtocolRef:
2888      return getCursorObjCProtocolRef(C).second;
2889
2890    case CXCursor_ObjCClassRef:
2891      return getCursorObjCClassRef(C).second;
2892
2893    case CXCursor_TypeRef:
2894      return getCursorTypeRef(C).second;
2895
2896    case CXCursor_TemplateRef:
2897      return getCursorTemplateRef(C).second;
2898
2899    case CXCursor_NamespaceRef:
2900      return getCursorNamespaceRef(C).second;
2901
2902    case CXCursor_MemberRef:
2903      return getCursorMemberRef(C).second;
2904
2905    case CXCursor_CXXBaseSpecifier:
2906      // FIXME: Figure out what source range to use for a CXBaseSpecifier.
2907      return SourceRange();
2908
2909    default:
2910      // FIXME: Need a way to enumerate all non-reference cases.
2911      llvm_unreachable("Missed a reference kind");
2912    }
2913  }
2914
2915  if (clang_isExpression(C.kind))
2916    return getCursorExpr(C)->getSourceRange();
2917
2918  if (clang_isStatement(C.kind))
2919    return getCursorStmt(C)->getSourceRange();
2920
2921  if (C.kind == CXCursor_PreprocessingDirective)
2922    return cxcursor::getCursorPreprocessingDirective(C);
2923
2924  if (C.kind == CXCursor_MacroInstantiation)
2925    return cxcursor::getCursorMacroInstantiation(C)->getSourceRange();
2926
2927  if (C.kind == CXCursor_MacroDefinition)
2928    return cxcursor::getCursorMacroDefinition(C)->getSourceRange();
2929
2930  if (C.kind >= CXCursor_FirstDecl && C.kind <= CXCursor_LastDecl)
2931    return getCursorDecl(C)->getSourceRange();
2932
2933  return SourceRange();
2934}
2935
2936extern "C" {
2937
2938CXSourceRange clang_getCursorExtent(CXCursor C) {
2939  SourceRange R = getRawCursorExtent(C);
2940  if (R.isInvalid())
2941    return clang_getNullRange();
2942
2943  return cxloc::translateSourceRange(getCursorContext(C), R);
2944}
2945
2946CXCursor clang_getCursorReferenced(CXCursor C) {
2947  if (clang_isInvalid(C.kind))
2948    return clang_getNullCursor();
2949
2950  ASTUnit *CXXUnit = getCursorASTUnit(C);
2951  if (clang_isDeclaration(C.kind))
2952    return C;
2953
2954  if (clang_isExpression(C.kind)) {
2955    Decl *D = getDeclFromExpr(getCursorExpr(C));
2956    if (D)
2957      return MakeCXCursor(D, CXXUnit);
2958    return clang_getNullCursor();
2959  }
2960
2961  if (C.kind == CXCursor_MacroInstantiation) {
2962    if (MacroDefinition *Def = getCursorMacroInstantiation(C)->getDefinition())
2963      return MakeMacroDefinitionCursor(Def, CXXUnit);
2964  }
2965
2966  if (!clang_isReference(C.kind))
2967    return clang_getNullCursor();
2968
2969  switch (C.kind) {
2970    case CXCursor_ObjCSuperClassRef:
2971      return MakeCXCursor(getCursorObjCSuperClassRef(C).first, CXXUnit);
2972
2973    case CXCursor_ObjCProtocolRef: {
2974      return MakeCXCursor(getCursorObjCProtocolRef(C).first, CXXUnit);
2975
2976    case CXCursor_ObjCClassRef:
2977      return MakeCXCursor(getCursorObjCClassRef(C).first, CXXUnit);
2978
2979    case CXCursor_TypeRef:
2980      return MakeCXCursor(getCursorTypeRef(C).first, CXXUnit);
2981
2982    case CXCursor_TemplateRef:
2983      return MakeCXCursor(getCursorTemplateRef(C).first, CXXUnit);
2984
2985    case CXCursor_NamespaceRef:
2986      return MakeCXCursor(getCursorNamespaceRef(C).first, CXXUnit);
2987
2988    case CXCursor_MemberRef:
2989      return MakeCXCursor(getCursorMemberRef(C).first, CXXUnit);
2990
2991    case CXCursor_CXXBaseSpecifier: {
2992      CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C);
2993      return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(),
2994                                                         CXXUnit));
2995    }
2996
2997    default:
2998      // We would prefer to enumerate all non-reference cursor kinds here.
2999      llvm_unreachable("Unhandled reference cursor kind");
3000      break;
3001    }
3002  }
3003
3004  return clang_getNullCursor();
3005}
3006
3007CXCursor clang_getCursorDefinition(CXCursor C) {
3008  if (clang_isInvalid(C.kind))
3009    return clang_getNullCursor();
3010
3011  ASTUnit *CXXUnit = getCursorASTUnit(C);
3012
3013  bool WasReference = false;
3014  if (clang_isReference(C.kind) || clang_isExpression(C.kind)) {
3015    C = clang_getCursorReferenced(C);
3016    WasReference = true;
3017  }
3018
3019  if (C.kind == CXCursor_MacroInstantiation)
3020    return clang_getCursorReferenced(C);
3021
3022  if (!clang_isDeclaration(C.kind))
3023    return clang_getNullCursor();
3024
3025  Decl *D = getCursorDecl(C);
3026  if (!D)
3027    return clang_getNullCursor();
3028
3029  switch (D->getKind()) {
3030  // Declaration kinds that don't really separate the notions of
3031  // declaration and definition.
3032  case Decl::Namespace:
3033  case Decl::Typedef:
3034  case Decl::TemplateTypeParm:
3035  case Decl::EnumConstant:
3036  case Decl::Field:
3037  case Decl::ObjCIvar:
3038  case Decl::ObjCAtDefsField:
3039  case Decl::ImplicitParam:
3040  case Decl::ParmVar:
3041  case Decl::NonTypeTemplateParm:
3042  case Decl::TemplateTemplateParm:
3043  case Decl::ObjCCategoryImpl:
3044  case Decl::ObjCImplementation:
3045  case Decl::AccessSpec:
3046  case Decl::LinkageSpec:
3047  case Decl::ObjCPropertyImpl:
3048  case Decl::FileScopeAsm:
3049  case Decl::StaticAssert:
3050  case Decl::Block:
3051    return C;
3052
3053  // Declaration kinds that don't make any sense here, but are
3054  // nonetheless harmless.
3055  case Decl::TranslationUnit:
3056    break;
3057
3058  // Declaration kinds for which the definition is not resolvable.
3059  case Decl::UnresolvedUsingTypename:
3060  case Decl::UnresolvedUsingValue:
3061    break;
3062
3063  case Decl::UsingDirective:
3064    return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(),
3065                        CXXUnit);
3066
3067  case Decl::NamespaceAlias:
3068    return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), CXXUnit);
3069
3070  case Decl::Enum:
3071  case Decl::Record:
3072  case Decl::CXXRecord:
3073  case Decl::ClassTemplateSpecialization:
3074  case Decl::ClassTemplatePartialSpecialization:
3075    if (TagDecl *Def = cast<TagDecl>(D)->getDefinition())
3076      return MakeCXCursor(Def, CXXUnit);
3077    return clang_getNullCursor();
3078
3079  case Decl::Function:
3080  case Decl::CXXMethod:
3081  case Decl::CXXConstructor:
3082  case Decl::CXXDestructor:
3083  case Decl::CXXConversion: {
3084    const FunctionDecl *Def = 0;
3085    if (cast<FunctionDecl>(D)->getBody(Def))
3086      return MakeCXCursor(const_cast<FunctionDecl *>(Def), CXXUnit);
3087    return clang_getNullCursor();
3088  }
3089
3090  case Decl::Var: {
3091    // Ask the variable if it has a definition.
3092    if (VarDecl *Def = cast<VarDecl>(D)->getDefinition())
3093      return MakeCXCursor(Def, CXXUnit);
3094    return clang_getNullCursor();
3095  }
3096
3097  case Decl::FunctionTemplate: {
3098    const FunctionDecl *Def = 0;
3099    if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def))
3100      return MakeCXCursor(Def->getDescribedFunctionTemplate(), CXXUnit);
3101    return clang_getNullCursor();
3102  }
3103
3104  case Decl::ClassTemplate: {
3105    if (RecordDecl *Def = cast<ClassTemplateDecl>(D)->getTemplatedDecl()
3106                                                            ->getDefinition())
3107      return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(),
3108                          CXXUnit);
3109    return clang_getNullCursor();
3110  }
3111
3112  case Decl::Using: {
3113    UsingDecl *Using = cast<UsingDecl>(D);
3114    CXCursor Def = clang_getNullCursor();
3115    for (UsingDecl::shadow_iterator S = Using->shadow_begin(),
3116                                 SEnd = Using->shadow_end();
3117         S != SEnd; ++S) {
3118      if (Def != clang_getNullCursor()) {
3119        // FIXME: We have no way to return multiple results.
3120        return clang_getNullCursor();
3121      }
3122
3123      Def = clang_getCursorDefinition(MakeCXCursor((*S)->getTargetDecl(),
3124                                                   CXXUnit));
3125    }
3126
3127    return Def;
3128  }
3129
3130  case Decl::UsingShadow:
3131    return clang_getCursorDefinition(
3132                       MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(),
3133                                    CXXUnit));
3134
3135  case Decl::ObjCMethod: {
3136    ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D);
3137    if (Method->isThisDeclarationADefinition())
3138      return C;
3139
3140    // Dig out the method definition in the associated
3141    // @implementation, if we have it.
3142    // FIXME: The ASTs should make finding the definition easier.
3143    if (ObjCInterfaceDecl *Class
3144                       = dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext()))
3145      if (ObjCImplementationDecl *ClassImpl = Class->getImplementation())
3146        if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(),
3147                                                  Method->isInstanceMethod()))
3148          if (Def->isThisDeclarationADefinition())
3149            return MakeCXCursor(Def, CXXUnit);
3150
3151    return clang_getNullCursor();
3152  }
3153
3154  case Decl::ObjCCategory:
3155    if (ObjCCategoryImplDecl *Impl
3156                               = cast<ObjCCategoryDecl>(D)->getImplementation())
3157      return MakeCXCursor(Impl, CXXUnit);
3158    return clang_getNullCursor();
3159
3160  case Decl::ObjCProtocol:
3161    if (!cast<ObjCProtocolDecl>(D)->isForwardDecl())
3162      return C;
3163    return clang_getNullCursor();
3164
3165  case Decl::ObjCInterface:
3166    // There are two notions of a "definition" for an Objective-C
3167    // class: the interface and its implementation. When we resolved a
3168    // reference to an Objective-C class, produce the @interface as
3169    // the definition; when we were provided with the interface,
3170    // produce the @implementation as the definition.
3171    if (WasReference) {
3172      if (!cast<ObjCInterfaceDecl>(D)->isForwardDecl())
3173        return C;
3174    } else if (ObjCImplementationDecl *Impl
3175                              = cast<ObjCInterfaceDecl>(D)->getImplementation())
3176      return MakeCXCursor(Impl, CXXUnit);
3177    return clang_getNullCursor();
3178
3179  case Decl::ObjCProperty:
3180    // FIXME: We don't really know where to find the
3181    // ObjCPropertyImplDecls that implement this property.
3182    return clang_getNullCursor();
3183
3184  case Decl::ObjCCompatibleAlias:
3185    if (ObjCInterfaceDecl *Class
3186          = cast<ObjCCompatibleAliasDecl>(D)->getClassInterface())
3187      if (!Class->isForwardDecl())
3188        return MakeCXCursor(Class, CXXUnit);
3189
3190    return clang_getNullCursor();
3191
3192  case Decl::ObjCForwardProtocol: {
3193    ObjCForwardProtocolDecl *Forward = cast<ObjCForwardProtocolDecl>(D);
3194    if (Forward->protocol_size() == 1)
3195      return clang_getCursorDefinition(
3196                                     MakeCXCursor(*Forward->protocol_begin(),
3197                                                  CXXUnit));
3198
3199    // FIXME: Cannot return multiple definitions.
3200    return clang_getNullCursor();
3201  }
3202
3203  case Decl::ObjCClass: {
3204    ObjCClassDecl *Class = cast<ObjCClassDecl>(D);
3205    if (Class->size() == 1) {
3206      ObjCInterfaceDecl *IFace = Class->begin()->getInterface();
3207      if (!IFace->isForwardDecl())
3208        return MakeCXCursor(IFace, CXXUnit);
3209      return clang_getNullCursor();
3210    }
3211
3212    // FIXME: Cannot return multiple definitions.
3213    return clang_getNullCursor();
3214  }
3215
3216  case Decl::Friend:
3217    if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl())
3218      return clang_getCursorDefinition(MakeCXCursor(Friend, CXXUnit));
3219    return clang_getNullCursor();
3220
3221  case Decl::FriendTemplate:
3222    if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl())
3223      return clang_getCursorDefinition(MakeCXCursor(Friend, CXXUnit));
3224    return clang_getNullCursor();
3225  }
3226
3227  return clang_getNullCursor();
3228}
3229
3230unsigned clang_isCursorDefinition(CXCursor C) {
3231  if (!clang_isDeclaration(C.kind))
3232    return 0;
3233
3234  return clang_getCursorDefinition(C) == C;
3235}
3236
3237void clang_getDefinitionSpellingAndExtent(CXCursor C,
3238                                          const char **startBuf,
3239                                          const char **endBuf,
3240                                          unsigned *startLine,
3241                                          unsigned *startColumn,
3242                                          unsigned *endLine,
3243                                          unsigned *endColumn) {
3244  assert(getCursorDecl(C) && "CXCursor has null decl");
3245  NamedDecl *ND = static_cast<NamedDecl *>(getCursorDecl(C));
3246  FunctionDecl *FD = dyn_cast<FunctionDecl>(ND);
3247  CompoundStmt *Body = dyn_cast<CompoundStmt>(FD->getBody());
3248
3249  SourceManager &SM = FD->getASTContext().getSourceManager();
3250  *startBuf = SM.getCharacterData(Body->getLBracLoc());
3251  *endBuf = SM.getCharacterData(Body->getRBracLoc());
3252  *startLine = SM.getSpellingLineNumber(Body->getLBracLoc());
3253  *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc());
3254  *endLine = SM.getSpellingLineNumber(Body->getRBracLoc());
3255  *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc());
3256}
3257
3258void clang_enableStackTraces(void) {
3259  llvm::sys::PrintStackTraceOnErrorSignal();
3260}
3261
3262} // end: extern "C"
3263
3264//===----------------------------------------------------------------------===//
3265// Token-based Operations.
3266//===----------------------------------------------------------------------===//
3267
3268/* CXToken layout:
3269 *   int_data[0]: a CXTokenKind
3270 *   int_data[1]: starting token location
3271 *   int_data[2]: token length
3272 *   int_data[3]: reserved
3273 *   ptr_data: for identifiers and keywords, an IdentifierInfo*.
3274 *   otherwise unused.
3275 */
3276extern "C" {
3277
3278CXTokenKind clang_getTokenKind(CXToken CXTok) {
3279  return static_cast<CXTokenKind>(CXTok.int_data[0]);
3280}
3281
3282CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) {
3283  switch (clang_getTokenKind(CXTok)) {
3284  case CXToken_Identifier:
3285  case CXToken_Keyword:
3286    // We know we have an IdentifierInfo*, so use that.
3287    return createCXString(static_cast<IdentifierInfo *>(CXTok.ptr_data)
3288                            ->getNameStart());
3289
3290  case CXToken_Literal: {
3291    // We have stashed the starting pointer in the ptr_data field. Use it.
3292    const char *Text = static_cast<const char *>(CXTok.ptr_data);
3293    return createCXString(llvm::StringRef(Text, CXTok.int_data[2]));
3294  }
3295
3296  case CXToken_Punctuation:
3297  case CXToken_Comment:
3298    break;
3299  }
3300
3301  // We have to find the starting buffer pointer the hard way, by
3302  // deconstructing the source location.
3303  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU);
3304  if (!CXXUnit)
3305    return createCXString("");
3306
3307  SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]);
3308  std::pair<FileID, unsigned> LocInfo
3309    = CXXUnit->getSourceManager().getDecomposedLoc(Loc);
3310  bool Invalid = false;
3311  llvm::StringRef Buffer
3312    = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid);
3313  if (Invalid)
3314    return createCXString("");
3315
3316  return createCXString(Buffer.substr(LocInfo.second, CXTok.int_data[2]));
3317}
3318
3319CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) {
3320  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU);
3321  if (!CXXUnit)
3322    return clang_getNullLocation();
3323
3324  return cxloc::translateSourceLocation(CXXUnit->getASTContext(),
3325                        SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
3326}
3327
3328CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) {
3329  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU);
3330  if (!CXXUnit)
3331    return clang_getNullRange();
3332
3333  return cxloc::translateSourceRange(CXXUnit->getASTContext(),
3334                        SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
3335}
3336
3337void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range,
3338                    CXToken **Tokens, unsigned *NumTokens) {
3339  if (Tokens)
3340    *Tokens = 0;
3341  if (NumTokens)
3342    *NumTokens = 0;
3343
3344  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU);
3345  if (!CXXUnit || !Tokens || !NumTokens)
3346    return;
3347
3348  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
3349
3350  SourceRange R = cxloc::translateCXSourceRange(Range);
3351  if (R.isInvalid())
3352    return;
3353
3354  SourceManager &SourceMgr = CXXUnit->getSourceManager();
3355  std::pair<FileID, unsigned> BeginLocInfo
3356    = SourceMgr.getDecomposedLoc(R.getBegin());
3357  std::pair<FileID, unsigned> EndLocInfo
3358    = SourceMgr.getDecomposedLoc(R.getEnd());
3359
3360  // Cannot tokenize across files.
3361  if (BeginLocInfo.first != EndLocInfo.first)
3362    return;
3363
3364  // Create a lexer
3365  bool Invalid = false;
3366  llvm::StringRef Buffer
3367    = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
3368  if (Invalid)
3369    return;
3370
3371  Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
3372            CXXUnit->getASTContext().getLangOptions(),
3373            Buffer.begin(), Buffer.data() + BeginLocInfo.second, Buffer.end());
3374  Lex.SetCommentRetentionState(true);
3375
3376  // Lex tokens until we hit the end of the range.
3377  const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second;
3378  llvm::SmallVector<CXToken, 32> CXTokens;
3379  Token Tok;
3380  do {
3381    // Lex the next token
3382    Lex.LexFromRawLexer(Tok);
3383    if (Tok.is(tok::eof))
3384      break;
3385
3386    // Initialize the CXToken.
3387    CXToken CXTok;
3388
3389    //   - Common fields
3390    CXTok.int_data[1] = Tok.getLocation().getRawEncoding();
3391    CXTok.int_data[2] = Tok.getLength();
3392    CXTok.int_data[3] = 0;
3393
3394    //   - Kind-specific fields
3395    if (Tok.isLiteral()) {
3396      CXTok.int_data[0] = CXToken_Literal;
3397      CXTok.ptr_data = (void *)Tok.getLiteralData();
3398    } else if (Tok.is(tok::identifier)) {
3399      // Lookup the identifier to determine whether we have a keyword.
3400      std::pair<FileID, unsigned> LocInfo
3401        = SourceMgr.getDecomposedLoc(Tok.getLocation());
3402      bool Invalid = false;
3403      llvm::StringRef Buf
3404        = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid);
3405      if (Invalid)
3406        return;
3407
3408      const char *StartPos = Buf.data() + LocInfo.second;
3409      IdentifierInfo *II
3410        = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok, StartPos);
3411
3412      if (II->getObjCKeywordID() != tok::objc_not_keyword) {
3413        CXTok.int_data[0] = CXToken_Keyword;
3414      }
3415      else {
3416        CXTok.int_data[0] = II->getTokenID() == tok::identifier?
3417                                CXToken_Identifier
3418                              : CXToken_Keyword;
3419      }
3420      CXTok.ptr_data = II;
3421    } else if (Tok.is(tok::comment)) {
3422      CXTok.int_data[0] = CXToken_Comment;
3423      CXTok.ptr_data = 0;
3424    } else {
3425      CXTok.int_data[0] = CXToken_Punctuation;
3426      CXTok.ptr_data = 0;
3427    }
3428    CXTokens.push_back(CXTok);
3429  } while (Lex.getBufferLocation() <= EffectiveBufferEnd);
3430
3431  if (CXTokens.empty())
3432    return;
3433
3434  *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size());
3435  memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size());
3436  *NumTokens = CXTokens.size();
3437}
3438
3439void clang_disposeTokens(CXTranslationUnit TU,
3440                         CXToken *Tokens, unsigned NumTokens) {
3441  free(Tokens);
3442}
3443
3444} // end: extern "C"
3445
3446//===----------------------------------------------------------------------===//
3447// Token annotation APIs.
3448//===----------------------------------------------------------------------===//
3449
3450typedef llvm::DenseMap<unsigned, CXCursor> AnnotateTokensData;
3451static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
3452                                                     CXCursor parent,
3453                                                     CXClientData client_data);
3454namespace {
3455class AnnotateTokensWorker {
3456  AnnotateTokensData &Annotated;
3457  CXToken *Tokens;
3458  CXCursor *Cursors;
3459  unsigned NumTokens;
3460  unsigned TokIdx;
3461  CursorVisitor AnnotateVis;
3462  SourceManager &SrcMgr;
3463
3464  bool MoreTokens() const { return TokIdx < NumTokens; }
3465  unsigned NextToken() const { return TokIdx; }
3466  void AdvanceToken() { ++TokIdx; }
3467  SourceLocation GetTokenLoc(unsigned tokI) {
3468    return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]);
3469  }
3470
3471public:
3472  AnnotateTokensWorker(AnnotateTokensData &annotated,
3473                       CXToken *tokens, CXCursor *cursors, unsigned numTokens,
3474                       ASTUnit *CXXUnit, SourceRange RegionOfInterest)
3475    : Annotated(annotated), Tokens(tokens), Cursors(cursors),
3476      NumTokens(numTokens), TokIdx(0),
3477      AnnotateVis(CXXUnit, AnnotateTokensVisitor, this,
3478                  Decl::MaxPCHLevel, RegionOfInterest),
3479      SrcMgr(CXXUnit->getSourceManager()) {}
3480
3481  void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); }
3482  enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent);
3483  void AnnotateTokens(CXCursor parent);
3484};
3485}
3486
3487void AnnotateTokensWorker::AnnotateTokens(CXCursor parent) {
3488  // Walk the AST within the region of interest, annotating tokens
3489  // along the way.
3490  VisitChildren(parent);
3491
3492  for (unsigned I = 0 ; I < TokIdx ; ++I) {
3493    AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]);
3494    if (Pos != Annotated.end())
3495      Cursors[I] = Pos->second;
3496  }
3497
3498  // Finish up annotating any tokens left.
3499  if (!MoreTokens())
3500    return;
3501
3502  const CXCursor &C = clang_getNullCursor();
3503  for (unsigned I = TokIdx ; I < NumTokens ; ++I) {
3504    AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]);
3505    Cursors[I] = (Pos == Annotated.end()) ? C : Pos->second;
3506  }
3507}
3508
3509enum CXChildVisitResult
3510AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) {
3511  CXSourceLocation Loc = clang_getCursorLocation(cursor);
3512  // We can always annotate a preprocessing directive/macro instantiation.
3513  if (clang_isPreprocessing(cursor.kind)) {
3514    Annotated[Loc.int_data] = cursor;
3515    return CXChildVisit_Recurse;
3516  }
3517
3518  SourceRange cursorRange = getRawCursorExtent(cursor);
3519
3520  if (cursorRange.isInvalid())
3521    return CXChildVisit_Continue;
3522
3523  SourceLocation L = SourceLocation::getFromRawEncoding(Loc.int_data);
3524
3525  // Adjust the annotated range based specific declarations.
3526  const enum CXCursorKind cursorK = clang_getCursorKind(cursor);
3527  if (cursorK >= CXCursor_FirstDecl && cursorK <= CXCursor_LastDecl) {
3528    Decl *D = cxcursor::getCursorDecl(cursor);
3529    // Don't visit synthesized ObjC methods, since they have no syntatic
3530    // representation in the source.
3531    if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
3532      if (MD->isSynthesized())
3533        return CXChildVisit_Continue;
3534    }
3535    if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
3536      if (TypeSourceInfo *TI = DD->getTypeSourceInfo()) {
3537        TypeLoc TL = TI->getTypeLoc();
3538        SourceLocation TLoc = TL.getSourceRange().getBegin();
3539        if (TLoc.isValid() &&
3540            SrcMgr.isBeforeInTranslationUnit(TLoc, L))
3541          cursorRange.setBegin(TLoc);
3542      }
3543    }
3544  }
3545
3546  // If the location of the cursor occurs within a macro instantiation, record
3547  // the spelling location of the cursor in our annotation map.  We can then
3548  // paper over the token labelings during a post-processing step to try and
3549  // get cursor mappings for tokens that are the *arguments* of a macro
3550  // instantiation.
3551  if (L.isMacroID()) {
3552    unsigned rawEncoding = SrcMgr.getSpellingLoc(L).getRawEncoding();
3553    // Only invalidate the old annotation if it isn't part of a preprocessing
3554    // directive.  Here we assume that the default construction of CXCursor
3555    // results in CXCursor.kind being an initialized value (i.e., 0).  If
3556    // this isn't the case, we can fix by doing lookup + insertion.
3557
3558    CXCursor &oldC = Annotated[rawEncoding];
3559    if (!clang_isPreprocessing(oldC.kind))
3560      oldC = cursor;
3561  }
3562
3563  const enum CXCursorKind K = clang_getCursorKind(parent);
3564  const CXCursor updateC =
3565    (clang_isInvalid(K) || K == CXCursor_TranslationUnit)
3566     ? clang_getNullCursor() : parent;
3567
3568  while (MoreTokens()) {
3569    const unsigned I = NextToken();
3570    SourceLocation TokLoc = GetTokenLoc(I);
3571    switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
3572      case RangeBefore:
3573        Cursors[I] = updateC;
3574        AdvanceToken();
3575        continue;
3576      case RangeAfter:
3577      case RangeOverlap:
3578        break;
3579    }
3580    break;
3581  }
3582
3583  // Visit children to get their cursor information.
3584  const unsigned BeforeChildren = NextToken();
3585  VisitChildren(cursor);
3586  const unsigned AfterChildren = NextToken();
3587
3588  // Adjust 'Last' to the last token within the extent of the cursor.
3589  while (MoreTokens()) {
3590    const unsigned I = NextToken();
3591    SourceLocation TokLoc = GetTokenLoc(I);
3592    switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
3593      case RangeBefore:
3594        assert(0 && "Infeasible");
3595      case RangeAfter:
3596        break;
3597      case RangeOverlap:
3598        Cursors[I] = updateC;
3599        AdvanceToken();
3600        continue;
3601    }
3602    break;
3603  }
3604  const unsigned Last = NextToken();
3605
3606  // Scan the tokens that are at the beginning of the cursor, but are not
3607  // capture by the child cursors.
3608
3609  // For AST elements within macros, rely on a post-annotate pass to
3610  // to correctly annotate the tokens with cursors.  Otherwise we can
3611  // get confusing results of having tokens that map to cursors that really
3612  // are expanded by an instantiation.
3613  if (L.isMacroID())
3614    cursor = clang_getNullCursor();
3615
3616  for (unsigned I = BeforeChildren; I != AfterChildren; ++I) {
3617    if (!clang_isInvalid(clang_getCursorKind(Cursors[I])))
3618      break;
3619    Cursors[I] = cursor;
3620  }
3621  // Scan the tokens that are at the end of the cursor, but are not captured
3622  // but the child cursors.
3623  for (unsigned I = AfterChildren; I != Last; ++I)
3624    Cursors[I] = cursor;
3625
3626  TokIdx = Last;
3627  return CXChildVisit_Continue;
3628}
3629
3630static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
3631                                                     CXCursor parent,
3632                                                     CXClientData client_data) {
3633  return static_cast<AnnotateTokensWorker*>(client_data)->Visit(cursor, parent);
3634}
3635
3636extern "C" {
3637
3638void clang_annotateTokens(CXTranslationUnit TU,
3639                          CXToken *Tokens, unsigned NumTokens,
3640                          CXCursor *Cursors) {
3641
3642  if (NumTokens == 0 || !Tokens || !Cursors)
3643    return;
3644
3645  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU);
3646  if (!CXXUnit) {
3647    // Any token we don't specifically annotate will have a NULL cursor.
3648    const CXCursor &C = clang_getNullCursor();
3649    for (unsigned I = 0; I != NumTokens; ++I)
3650      Cursors[I] = C;
3651    return;
3652  }
3653
3654  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
3655
3656  // Determine the region of interest, which contains all of the tokens.
3657  SourceRange RegionOfInterest;
3658  RegionOfInterest.setBegin(cxloc::translateSourceLocation(
3659                                        clang_getTokenLocation(TU, Tokens[0])));
3660  RegionOfInterest.setEnd(cxloc::translateSourceLocation(
3661                                clang_getTokenLocation(TU,
3662                                                       Tokens[NumTokens - 1])));
3663
3664  // A mapping from the source locations found when re-lexing or traversing the
3665  // region of interest to the corresponding cursors.
3666  AnnotateTokensData Annotated;
3667
3668  // Relex the tokens within the source range to look for preprocessing
3669  // directives.
3670  SourceManager &SourceMgr = CXXUnit->getSourceManager();
3671  std::pair<FileID, unsigned> BeginLocInfo
3672    = SourceMgr.getDecomposedLoc(RegionOfInterest.getBegin());
3673  std::pair<FileID, unsigned> EndLocInfo
3674    = SourceMgr.getDecomposedLoc(RegionOfInterest.getEnd());
3675
3676  llvm::StringRef Buffer;
3677  bool Invalid = false;
3678  if (BeginLocInfo.first == EndLocInfo.first &&
3679      ((Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid)),true) &&
3680      !Invalid) {
3681    Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
3682              CXXUnit->getASTContext().getLangOptions(),
3683              Buffer.begin(), Buffer.data() + BeginLocInfo.second,
3684              Buffer.end());
3685    Lex.SetCommentRetentionState(true);
3686
3687    // Lex tokens in raw mode until we hit the end of the range, to avoid
3688    // entering #includes or expanding macros.
3689    while (true) {
3690      Token Tok;
3691      Lex.LexFromRawLexer(Tok);
3692
3693    reprocess:
3694      if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) {
3695        // We have found a preprocessing directive. Gobble it up so that we
3696        // don't see it while preprocessing these tokens later, but keep track of
3697        // all of the token locations inside this preprocessing directive so that
3698        // we can annotate them appropriately.
3699        //
3700        // FIXME: Some simple tests here could identify macro definitions and
3701        // #undefs, to provide specific cursor kinds for those.
3702        std::vector<SourceLocation> Locations;
3703        do {
3704          Locations.push_back(Tok.getLocation());
3705          Lex.LexFromRawLexer(Tok);
3706        } while (!Tok.isAtStartOfLine() && !Tok.is(tok::eof));
3707
3708        using namespace cxcursor;
3709        CXCursor Cursor
3710          = MakePreprocessingDirectiveCursor(SourceRange(Locations.front(),
3711                                                         Locations.back()),
3712                                           CXXUnit);
3713        for (unsigned I = 0, N = Locations.size(); I != N; ++I) {
3714          Annotated[Locations[I].getRawEncoding()] = Cursor;
3715        }
3716
3717        if (Tok.isAtStartOfLine())
3718          goto reprocess;
3719
3720        continue;
3721      }
3722
3723      if (Tok.is(tok::eof))
3724        break;
3725    }
3726  }
3727
3728  // Annotate all of the source locations in the region of interest that map to
3729  // a specific cursor.
3730  AnnotateTokensWorker W(Annotated, Tokens, Cursors, NumTokens,
3731                         CXXUnit, RegionOfInterest);
3732  W.AnnotateTokens(clang_getTranslationUnitCursor(CXXUnit));
3733}
3734} // end: extern "C"
3735
3736//===----------------------------------------------------------------------===//
3737// Operations for querying linkage of a cursor.
3738//===----------------------------------------------------------------------===//
3739
3740extern "C" {
3741CXLinkageKind clang_getCursorLinkage(CXCursor cursor) {
3742  if (!clang_isDeclaration(cursor.kind))
3743    return CXLinkage_Invalid;
3744
3745  Decl *D = cxcursor::getCursorDecl(cursor);
3746  if (NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D))
3747    switch (ND->getLinkage()) {
3748      case NoLinkage: return CXLinkage_NoLinkage;
3749      case InternalLinkage: return CXLinkage_Internal;
3750      case UniqueExternalLinkage: return CXLinkage_UniqueExternal;
3751      case ExternalLinkage: return CXLinkage_External;
3752    };
3753
3754  return CXLinkage_Invalid;
3755}
3756} // end: extern "C"
3757
3758//===----------------------------------------------------------------------===//
3759// Operations for querying language of a cursor.
3760//===----------------------------------------------------------------------===//
3761
3762static CXLanguageKind getDeclLanguage(const Decl *D) {
3763  switch (D->getKind()) {
3764    default:
3765      break;
3766    case Decl::ImplicitParam:
3767    case Decl::ObjCAtDefsField:
3768    case Decl::ObjCCategory:
3769    case Decl::ObjCCategoryImpl:
3770    case Decl::ObjCClass:
3771    case Decl::ObjCCompatibleAlias:
3772    case Decl::ObjCForwardProtocol:
3773    case Decl::ObjCImplementation:
3774    case Decl::ObjCInterface:
3775    case Decl::ObjCIvar:
3776    case Decl::ObjCMethod:
3777    case Decl::ObjCProperty:
3778    case Decl::ObjCPropertyImpl:
3779    case Decl::ObjCProtocol:
3780      return CXLanguage_ObjC;
3781    case Decl::CXXConstructor:
3782    case Decl::CXXConversion:
3783    case Decl::CXXDestructor:
3784    case Decl::CXXMethod:
3785    case Decl::CXXRecord:
3786    case Decl::ClassTemplate:
3787    case Decl::ClassTemplatePartialSpecialization:
3788    case Decl::ClassTemplateSpecialization:
3789    case Decl::Friend:
3790    case Decl::FriendTemplate:
3791    case Decl::FunctionTemplate:
3792    case Decl::LinkageSpec:
3793    case Decl::Namespace:
3794    case Decl::NamespaceAlias:
3795    case Decl::NonTypeTemplateParm:
3796    case Decl::StaticAssert:
3797    case Decl::TemplateTemplateParm:
3798    case Decl::TemplateTypeParm:
3799    case Decl::UnresolvedUsingTypename:
3800    case Decl::UnresolvedUsingValue:
3801    case Decl::Using:
3802    case Decl::UsingDirective:
3803    case Decl::UsingShadow:
3804      return CXLanguage_CPlusPlus;
3805  }
3806
3807  return CXLanguage_C;
3808}
3809
3810extern "C" {
3811
3812enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) {
3813  if (clang_isDeclaration(cursor.kind))
3814    if (Decl *D = cxcursor::getCursorDecl(cursor)) {
3815      if (D->hasAttr<UnavailableAttr>() ||
3816          (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted()))
3817        return CXAvailability_Available;
3818
3819      if (D->hasAttr<DeprecatedAttr>())
3820        return CXAvailability_Deprecated;
3821    }
3822
3823  return CXAvailability_Available;
3824}
3825
3826CXLanguageKind clang_getCursorLanguage(CXCursor cursor) {
3827  if (clang_isDeclaration(cursor.kind))
3828    return getDeclLanguage(cxcursor::getCursorDecl(cursor));
3829
3830  return CXLanguage_Invalid;
3831}
3832} // end: extern "C"
3833
3834
3835//===----------------------------------------------------------------------===//
3836// C++ AST instrospection.
3837//===----------------------------------------------------------------------===//
3838
3839extern "C" {
3840unsigned clang_CXXMethod_isStatic(CXCursor C) {
3841  if (!clang_isDeclaration(C.kind))
3842    return 0;
3843
3844  CXXMethodDecl *Method = 0;
3845  Decl *D = cxcursor::getCursorDecl(C);
3846  if (FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(D))
3847    Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
3848  else
3849    Method = dyn_cast_or_null<CXXMethodDecl>(D);
3850  return (Method && Method->isStatic()) ? 1 : 0;
3851}
3852
3853} // end: extern "C"
3854
3855//===----------------------------------------------------------------------===//
3856// Attribute introspection.
3857//===----------------------------------------------------------------------===//
3858
3859extern "C" {
3860CXType clang_getIBOutletCollectionType(CXCursor C) {
3861  if (C.kind != CXCursor_IBOutletCollectionAttr)
3862    return cxtype::MakeCXType(QualType(), cxcursor::getCursorASTUnit(C));
3863
3864  IBOutletCollectionAttr *A =
3865    cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C));
3866
3867  return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorASTUnit(C));
3868}
3869} // end: extern "C"
3870
3871//===----------------------------------------------------------------------===//
3872// CXString Operations.
3873//===----------------------------------------------------------------------===//
3874
3875extern "C" {
3876const char *clang_getCString(CXString string) {
3877  return string.Spelling;
3878}
3879
3880void clang_disposeString(CXString string) {
3881  if (string.MustFreeString && string.Spelling)
3882    free((void*)string.Spelling);
3883}
3884
3885} // end: extern "C"
3886
3887namespace clang { namespace cxstring {
3888CXString createCXString(const char *String, bool DupString){
3889  CXString Str;
3890  if (DupString) {
3891    Str.Spelling = strdup(String);
3892    Str.MustFreeString = 1;
3893  } else {
3894    Str.Spelling = String;
3895    Str.MustFreeString = 0;
3896  }
3897  return Str;
3898}
3899
3900CXString createCXString(llvm::StringRef String, bool DupString) {
3901  CXString Result;
3902  if (DupString || (!String.empty() && String.data()[String.size()] != 0)) {
3903    char *Spelling = (char *)malloc(String.size() + 1);
3904    memmove(Spelling, String.data(), String.size());
3905    Spelling[String.size()] = 0;
3906    Result.Spelling = Spelling;
3907    Result.MustFreeString = 1;
3908  } else {
3909    Result.Spelling = String.data();
3910    Result.MustFreeString = 0;
3911  }
3912  return Result;
3913}
3914}}
3915
3916//===----------------------------------------------------------------------===//
3917// Misc. utility functions.
3918//===----------------------------------------------------------------------===//
3919
3920extern "C" {
3921
3922CXString clang_getClangVersion() {
3923  return createCXString(getClangFullVersion());
3924}
3925
3926} // end: extern "C"
3927