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