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