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