CIndex.cpp revision b085d898bdfe35097eba45f4072b0f6865f561dc 
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    setThreadBackgroundPriority();
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    setThreadBackgroundPriority();
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    setThreadBackgroundPriority();
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    if (PRE->isExplicitProperty())
2906      return PRE->getExplicitProperty();
2907    // It could be messaging both getter and setter as in:
2908    // ++myobj.myprop;
2909    // in which case prefer to associate the setter since it is less obvious
2910    // from inspecting the source that the setter is going to get called.
2911    if (PRE->isMessagingSetter())
2912      return PRE->getImplicitPropertySetter();
2913    return PRE->getImplicitPropertyGetter();
2914  }
2915  if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
2916    return getDeclFromExpr(POE->getSyntacticForm());
2917  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E))
2918    if (Expr *Src = OVE->getSourceExpr())
2919      return getDeclFromExpr(Src);
2920
2921  if (CallExpr *CE = dyn_cast<CallExpr>(E))
2922    return getDeclFromExpr(CE->getCallee());
2923  if (CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E))
2924    if (!CE->isElidable())
2925    return CE->getConstructor();
2926  if (ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E))
2927    return OME->getMethodDecl();
2928
2929  if (ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E))
2930    return PE->getProtocol();
2931  if (SubstNonTypeTemplateParmPackExpr *NTTP
2932                              = dyn_cast<SubstNonTypeTemplateParmPackExpr>(E))
2933    return NTTP->getParameterPack();
2934  if (SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
2935    if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) ||
2936        isa<ParmVarDecl>(SizeOfPack->getPack()))
2937      return SizeOfPack->getPack();
2938
2939  return 0;
2940}
2941
2942static SourceLocation getLocationFromExpr(Expr *E) {
2943  if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
2944    return getLocationFromExpr(CE->getSubExpr());
2945
2946  if (ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E))
2947    return /*FIXME:*/Msg->getLeftLoc();
2948  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
2949    return DRE->getLocation();
2950  if (MemberExpr *Member = dyn_cast<MemberExpr>(E))
2951    return Member->getMemberLoc();
2952  if (ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E))
2953    return Ivar->getLocation();
2954  if (SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E))
2955    return SizeOfPack->getPackLoc();
2956  if (ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E))
2957    return PropRef->getLocation();
2958
2959  return E->getLocStart();
2960}
2961
2962extern "C" {
2963
2964unsigned clang_visitChildren(CXCursor parent,
2965                             CXCursorVisitor visitor,
2966                             CXClientData client_data) {
2967  CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data,
2968                          /*VisitPreprocessorLast=*/false);
2969  return CursorVis.VisitChildren(parent);
2970}
2971
2972#ifndef __has_feature
2973#define __has_feature(x) 0
2974#endif
2975#if __has_feature(blocks)
2976typedef enum CXChildVisitResult
2977     (^CXCursorVisitorBlock)(CXCursor cursor, CXCursor parent);
2978
2979static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
2980    CXClientData client_data) {
2981  CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
2982  return block(cursor, parent);
2983}
2984#else
2985// If we are compiled with a compiler that doesn't have native blocks support,
2986// define and call the block manually, so the
2987typedef struct _CXChildVisitResult
2988{
2989	void *isa;
2990	int flags;
2991	int reserved;
2992	enum CXChildVisitResult(*invoke)(struct _CXChildVisitResult*, CXCursor,
2993                                         CXCursor);
2994} *CXCursorVisitorBlock;
2995
2996static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent,
2997    CXClientData client_data) {
2998  CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data;
2999  return block->invoke(block, cursor, parent);
3000}
3001#endif
3002
3003
3004unsigned clang_visitChildrenWithBlock(CXCursor parent,
3005                                      CXCursorVisitorBlock block) {
3006  return clang_visitChildren(parent, visitWithBlock, block);
3007}
3008
3009static CXString getDeclSpelling(Decl *D) {
3010  if (!D)
3011    return createCXString("");
3012
3013  NamedDecl *ND = dyn_cast<NamedDecl>(D);
3014  if (!ND) {
3015    if (ObjCPropertyImplDecl *PropImpl =dyn_cast<ObjCPropertyImplDecl>(D))
3016      if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
3017        return createCXString(Property->getIdentifier()->getName());
3018
3019    return createCXString("");
3020  }
3021
3022  if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
3023    return createCXString(OMD->getSelector().getAsString());
3024
3025  if (ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND))
3026    // No, this isn't the same as the code below. getIdentifier() is non-virtual
3027    // and returns different names. NamedDecl returns the class name and
3028    // ObjCCategoryImplDecl returns the category name.
3029    return createCXString(CIMP->getIdentifier()->getNameStart());
3030
3031  if (isa<UsingDirectiveDecl>(D))
3032    return createCXString("");
3033
3034  SmallString<1024> S;
3035  llvm::raw_svector_ostream os(S);
3036  ND->printName(os);
3037
3038  return createCXString(os.str());
3039}
3040
3041CXString clang_getCursorSpelling(CXCursor C) {
3042  if (clang_isTranslationUnit(C.kind))
3043    return clang_getTranslationUnitSpelling(
3044                            static_cast<CXTranslationUnit>(C.data[2]));
3045
3046  if (clang_isReference(C.kind)) {
3047    switch (C.kind) {
3048    case CXCursor_ObjCSuperClassRef: {
3049      ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first;
3050      return createCXString(Super->getIdentifier()->getNameStart());
3051    }
3052    case CXCursor_ObjCClassRef: {
3053      ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
3054      return createCXString(Class->getIdentifier()->getNameStart());
3055    }
3056    case CXCursor_ObjCProtocolRef: {
3057      ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first;
3058      assert(OID && "getCursorSpelling(): Missing protocol decl");
3059      return createCXString(OID->getIdentifier()->getNameStart());
3060    }
3061    case CXCursor_CXXBaseSpecifier: {
3062      CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C);
3063      return createCXString(B->getType().getAsString());
3064    }
3065    case CXCursor_TypeRef: {
3066      TypeDecl *Type = getCursorTypeRef(C).first;
3067      assert(Type && "Missing type decl");
3068
3069      return createCXString(getCursorContext(C).getTypeDeclType(Type).
3070                              getAsString());
3071    }
3072    case CXCursor_TemplateRef: {
3073      TemplateDecl *Template = getCursorTemplateRef(C).first;
3074      assert(Template && "Missing template decl");
3075
3076      return createCXString(Template->getNameAsString());
3077    }
3078
3079    case CXCursor_NamespaceRef: {
3080      NamedDecl *NS = getCursorNamespaceRef(C).first;
3081      assert(NS && "Missing namespace decl");
3082
3083      return createCXString(NS->getNameAsString());
3084    }
3085
3086    case CXCursor_MemberRef: {
3087      FieldDecl *Field = getCursorMemberRef(C).first;
3088      assert(Field && "Missing member decl");
3089
3090      return createCXString(Field->getNameAsString());
3091    }
3092
3093    case CXCursor_LabelRef: {
3094      LabelStmt *Label = getCursorLabelRef(C).first;
3095      assert(Label && "Missing label");
3096
3097      return createCXString(Label->getName());
3098    }
3099
3100    case CXCursor_OverloadedDeclRef: {
3101      OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
3102      if (Decl *D = Storage.dyn_cast<Decl *>()) {
3103        if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
3104          return createCXString(ND->getNameAsString());
3105        return createCXString("");
3106      }
3107      if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>())
3108        return createCXString(E->getName().getAsString());
3109      OverloadedTemplateStorage *Ovl
3110        = Storage.get<OverloadedTemplateStorage*>();
3111      if (Ovl->size() == 0)
3112        return createCXString("");
3113      return createCXString((*Ovl->begin())->getNameAsString());
3114    }
3115
3116    case CXCursor_VariableRef: {
3117      VarDecl *Var = getCursorVariableRef(C).first;
3118      assert(Var && "Missing variable decl");
3119
3120      return createCXString(Var->getNameAsString());
3121    }
3122
3123    default:
3124      return createCXString("<not implemented>");
3125    }
3126  }
3127
3128  if (clang_isExpression(C.kind)) {
3129    Decl *D = getDeclFromExpr(getCursorExpr(C));
3130    if (D)
3131      return getDeclSpelling(D);
3132    return createCXString("");
3133  }
3134
3135  if (clang_isStatement(C.kind)) {
3136    Stmt *S = getCursorStmt(C);
3137    if (LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
3138      return createCXString(Label->getName());
3139
3140    return createCXString("");
3141  }
3142
3143  if (C.kind == CXCursor_MacroExpansion)
3144    return createCXString(getCursorMacroExpansion(C)->getName()
3145                                                           ->getNameStart());
3146
3147  if (C.kind == CXCursor_MacroDefinition)
3148    return createCXString(getCursorMacroDefinition(C)->getName()
3149                                                           ->getNameStart());
3150
3151  if (C.kind == CXCursor_InclusionDirective)
3152    return createCXString(getCursorInclusionDirective(C)->getFileName());
3153
3154  if (clang_isDeclaration(C.kind))
3155    return getDeclSpelling(getCursorDecl(C));
3156
3157  if (C.kind == CXCursor_AnnotateAttr) {
3158    AnnotateAttr *AA = cast<AnnotateAttr>(cxcursor::getCursorAttr(C));
3159    return createCXString(AA->getAnnotation());
3160  }
3161
3162  if (C.kind == CXCursor_AsmLabelAttr) {
3163    AsmLabelAttr *AA = cast<AsmLabelAttr>(cxcursor::getCursorAttr(C));
3164    return createCXString(AA->getLabel());
3165  }
3166
3167  return createCXString("");
3168}
3169
3170CXString clang_getCursorDisplayName(CXCursor C) {
3171  if (!clang_isDeclaration(C.kind))
3172    return clang_getCursorSpelling(C);
3173
3174  Decl *D = getCursorDecl(C);
3175  if (!D)
3176    return createCXString("");
3177
3178  PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy();
3179  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
3180    D = FunTmpl->getTemplatedDecl();
3181
3182  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
3183    SmallString<64> Str;
3184    llvm::raw_svector_ostream OS(Str);
3185    OS << *Function;
3186    if (Function->getPrimaryTemplate())
3187      OS << "<>";
3188    OS << "(";
3189    for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) {
3190      if (I)
3191        OS << ", ";
3192      OS << Function->getParamDecl(I)->getType().getAsString(Policy);
3193    }
3194
3195    if (Function->isVariadic()) {
3196      if (Function->getNumParams())
3197        OS << ", ";
3198      OS << "...";
3199    }
3200    OS << ")";
3201    return createCXString(OS.str());
3202  }
3203
3204  if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) {
3205    SmallString<64> Str;
3206    llvm::raw_svector_ostream OS(Str);
3207    OS << *ClassTemplate;
3208    OS << "<";
3209    TemplateParameterList *Params = ClassTemplate->getTemplateParameters();
3210    for (unsigned I = 0, N = Params->size(); I != N; ++I) {
3211      if (I)
3212        OS << ", ";
3213
3214      NamedDecl *Param = Params->getParam(I);
3215      if (Param->getIdentifier()) {
3216        OS << Param->getIdentifier()->getName();
3217        continue;
3218      }
3219
3220      // There is no parameter name, which makes this tricky. Try to come up
3221      // with something useful that isn't too long.
3222      if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
3223        OS << (TTP->wasDeclaredWithTypename()? "typename" : "class");
3224      else if (NonTypeTemplateParmDecl *NTTP
3225                                    = dyn_cast<NonTypeTemplateParmDecl>(Param))
3226        OS << NTTP->getType().getAsString(Policy);
3227      else
3228        OS << "template<...> class";
3229    }
3230
3231    OS << ">";
3232    return createCXString(OS.str());
3233  }
3234
3235  if (ClassTemplateSpecializationDecl *ClassSpec
3236                              = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
3237    // If the type was explicitly written, use that.
3238    if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten())
3239      return createCXString(TSInfo->getType().getAsString(Policy));
3240
3241    SmallString<64> Str;
3242    llvm::raw_svector_ostream OS(Str);
3243    OS << *ClassSpec;
3244    OS << TemplateSpecializationType::PrintTemplateArgumentList(
3245                                      ClassSpec->getTemplateArgs().data(),
3246                                      ClassSpec->getTemplateArgs().size(),
3247                                                                Policy);
3248    return createCXString(OS.str());
3249  }
3250
3251  return clang_getCursorSpelling(C);
3252}
3253
3254CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
3255  switch (Kind) {
3256  case CXCursor_FunctionDecl:
3257      return createCXString("FunctionDecl");
3258  case CXCursor_TypedefDecl:
3259      return createCXString("TypedefDecl");
3260  case CXCursor_EnumDecl:
3261      return createCXString("EnumDecl");
3262  case CXCursor_EnumConstantDecl:
3263      return createCXString("EnumConstantDecl");
3264  case CXCursor_StructDecl:
3265      return createCXString("StructDecl");
3266  case CXCursor_UnionDecl:
3267      return createCXString("UnionDecl");
3268  case CXCursor_ClassDecl:
3269      return createCXString("ClassDecl");
3270  case CXCursor_FieldDecl:
3271      return createCXString("FieldDecl");
3272  case CXCursor_VarDecl:
3273      return createCXString("VarDecl");
3274  case CXCursor_ParmDecl:
3275      return createCXString("ParmDecl");
3276  case CXCursor_ObjCInterfaceDecl:
3277      return createCXString("ObjCInterfaceDecl");
3278  case CXCursor_ObjCCategoryDecl:
3279      return createCXString("ObjCCategoryDecl");
3280  case CXCursor_ObjCProtocolDecl:
3281      return createCXString("ObjCProtocolDecl");
3282  case CXCursor_ObjCPropertyDecl:
3283      return createCXString("ObjCPropertyDecl");
3284  case CXCursor_ObjCIvarDecl:
3285      return createCXString("ObjCIvarDecl");
3286  case CXCursor_ObjCInstanceMethodDecl:
3287      return createCXString("ObjCInstanceMethodDecl");
3288  case CXCursor_ObjCClassMethodDecl:
3289      return createCXString("ObjCClassMethodDecl");
3290  case CXCursor_ObjCImplementationDecl:
3291      return createCXString("ObjCImplementationDecl");
3292  case CXCursor_ObjCCategoryImplDecl:
3293      return createCXString("ObjCCategoryImplDecl");
3294  case CXCursor_CXXMethod:
3295      return createCXString("CXXMethod");
3296  case CXCursor_UnexposedDecl:
3297      return createCXString("UnexposedDecl");
3298  case CXCursor_ObjCSuperClassRef:
3299      return createCXString("ObjCSuperClassRef");
3300  case CXCursor_ObjCProtocolRef:
3301      return createCXString("ObjCProtocolRef");
3302  case CXCursor_ObjCClassRef:
3303      return createCXString("ObjCClassRef");
3304  case CXCursor_TypeRef:
3305      return createCXString("TypeRef");
3306  case CXCursor_TemplateRef:
3307      return createCXString("TemplateRef");
3308  case CXCursor_NamespaceRef:
3309    return createCXString("NamespaceRef");
3310  case CXCursor_MemberRef:
3311    return createCXString("MemberRef");
3312  case CXCursor_LabelRef:
3313    return createCXString("LabelRef");
3314  case CXCursor_OverloadedDeclRef:
3315    return createCXString("OverloadedDeclRef");
3316  case CXCursor_VariableRef:
3317    return createCXString("VariableRef");
3318  case CXCursor_IntegerLiteral:
3319      return createCXString("IntegerLiteral");
3320  case CXCursor_FloatingLiteral:
3321      return createCXString("FloatingLiteral");
3322  case CXCursor_ImaginaryLiteral:
3323      return createCXString("ImaginaryLiteral");
3324  case CXCursor_StringLiteral:
3325      return createCXString("StringLiteral");
3326  case CXCursor_CharacterLiteral:
3327      return createCXString("CharacterLiteral");
3328  case CXCursor_ParenExpr:
3329      return createCXString("ParenExpr");
3330  case CXCursor_UnaryOperator:
3331      return createCXString("UnaryOperator");
3332  case CXCursor_ArraySubscriptExpr:
3333      return createCXString("ArraySubscriptExpr");
3334  case CXCursor_BinaryOperator:
3335      return createCXString("BinaryOperator");
3336  case CXCursor_CompoundAssignOperator:
3337      return createCXString("CompoundAssignOperator");
3338  case CXCursor_ConditionalOperator:
3339      return createCXString("ConditionalOperator");
3340  case CXCursor_CStyleCastExpr:
3341      return createCXString("CStyleCastExpr");
3342  case CXCursor_CompoundLiteralExpr:
3343      return createCXString("CompoundLiteralExpr");
3344  case CXCursor_InitListExpr:
3345      return createCXString("InitListExpr");
3346  case CXCursor_AddrLabelExpr:
3347      return createCXString("AddrLabelExpr");
3348  case CXCursor_StmtExpr:
3349      return createCXString("StmtExpr");
3350  case CXCursor_GenericSelectionExpr:
3351      return createCXString("GenericSelectionExpr");
3352  case CXCursor_GNUNullExpr:
3353      return createCXString("GNUNullExpr");
3354  case CXCursor_CXXStaticCastExpr:
3355      return createCXString("CXXStaticCastExpr");
3356  case CXCursor_CXXDynamicCastExpr:
3357      return createCXString("CXXDynamicCastExpr");
3358  case CXCursor_CXXReinterpretCastExpr:
3359      return createCXString("CXXReinterpretCastExpr");
3360  case CXCursor_CXXConstCastExpr:
3361      return createCXString("CXXConstCastExpr");
3362  case CXCursor_CXXFunctionalCastExpr:
3363      return createCXString("CXXFunctionalCastExpr");
3364  case CXCursor_CXXTypeidExpr:
3365      return createCXString("CXXTypeidExpr");
3366  case CXCursor_CXXBoolLiteralExpr:
3367      return createCXString("CXXBoolLiteralExpr");
3368  case CXCursor_CXXNullPtrLiteralExpr:
3369      return createCXString("CXXNullPtrLiteralExpr");
3370  case CXCursor_CXXThisExpr:
3371      return createCXString("CXXThisExpr");
3372  case CXCursor_CXXThrowExpr:
3373      return createCXString("CXXThrowExpr");
3374  case CXCursor_CXXNewExpr:
3375      return createCXString("CXXNewExpr");
3376  case CXCursor_CXXDeleteExpr:
3377      return createCXString("CXXDeleteExpr");
3378  case CXCursor_UnaryExpr:
3379      return createCXString("UnaryExpr");
3380  case CXCursor_ObjCStringLiteral:
3381      return createCXString("ObjCStringLiteral");
3382  case CXCursor_ObjCBoolLiteralExpr:
3383      return createCXString("ObjCBoolLiteralExpr");
3384  case CXCursor_ObjCEncodeExpr:
3385      return createCXString("ObjCEncodeExpr");
3386  case CXCursor_ObjCSelectorExpr:
3387      return createCXString("ObjCSelectorExpr");
3388  case CXCursor_ObjCProtocolExpr:
3389      return createCXString("ObjCProtocolExpr");
3390  case CXCursor_ObjCBridgedCastExpr:
3391      return createCXString("ObjCBridgedCastExpr");
3392  case CXCursor_BlockExpr:
3393      return createCXString("BlockExpr");
3394  case CXCursor_PackExpansionExpr:
3395      return createCXString("PackExpansionExpr");
3396  case CXCursor_SizeOfPackExpr:
3397      return createCXString("SizeOfPackExpr");
3398  case CXCursor_LambdaExpr:
3399    return createCXString("LambdaExpr");
3400  case CXCursor_UnexposedExpr:
3401      return createCXString("UnexposedExpr");
3402  case CXCursor_DeclRefExpr:
3403      return createCXString("DeclRefExpr");
3404  case CXCursor_MemberRefExpr:
3405      return createCXString("MemberRefExpr");
3406  case CXCursor_CallExpr:
3407      return createCXString("CallExpr");
3408  case CXCursor_ObjCMessageExpr:
3409      return createCXString("ObjCMessageExpr");
3410  case CXCursor_UnexposedStmt:
3411      return createCXString("UnexposedStmt");
3412  case CXCursor_DeclStmt:
3413      return createCXString("DeclStmt");
3414  case CXCursor_LabelStmt:
3415      return createCXString("LabelStmt");
3416  case CXCursor_CompoundStmt:
3417      return createCXString("CompoundStmt");
3418  case CXCursor_CaseStmt:
3419      return createCXString("CaseStmt");
3420  case CXCursor_DefaultStmt:
3421      return createCXString("DefaultStmt");
3422  case CXCursor_IfStmt:
3423      return createCXString("IfStmt");
3424  case CXCursor_SwitchStmt:
3425      return createCXString("SwitchStmt");
3426  case CXCursor_WhileStmt:
3427      return createCXString("WhileStmt");
3428  case CXCursor_DoStmt:
3429      return createCXString("DoStmt");
3430  case CXCursor_ForStmt:
3431      return createCXString("ForStmt");
3432  case CXCursor_GotoStmt:
3433      return createCXString("GotoStmt");
3434  case CXCursor_IndirectGotoStmt:
3435      return createCXString("IndirectGotoStmt");
3436  case CXCursor_ContinueStmt:
3437      return createCXString("ContinueStmt");
3438  case CXCursor_BreakStmt:
3439      return createCXString("BreakStmt");
3440  case CXCursor_ReturnStmt:
3441      return createCXString("ReturnStmt");
3442  case CXCursor_AsmStmt:
3443      return createCXString("AsmStmt");
3444  case CXCursor_ObjCAtTryStmt:
3445      return createCXString("ObjCAtTryStmt");
3446  case CXCursor_ObjCAtCatchStmt:
3447      return createCXString("ObjCAtCatchStmt");
3448  case CXCursor_ObjCAtFinallyStmt:
3449      return createCXString("ObjCAtFinallyStmt");
3450  case CXCursor_ObjCAtThrowStmt:
3451      return createCXString("ObjCAtThrowStmt");
3452  case CXCursor_ObjCAtSynchronizedStmt:
3453      return createCXString("ObjCAtSynchronizedStmt");
3454  case CXCursor_ObjCAutoreleasePoolStmt:
3455      return createCXString("ObjCAutoreleasePoolStmt");
3456  case CXCursor_ObjCForCollectionStmt:
3457      return createCXString("ObjCForCollectionStmt");
3458  case CXCursor_CXXCatchStmt:
3459      return createCXString("CXXCatchStmt");
3460  case CXCursor_CXXTryStmt:
3461      return createCXString("CXXTryStmt");
3462  case CXCursor_CXXForRangeStmt:
3463      return createCXString("CXXForRangeStmt");
3464  case CXCursor_SEHTryStmt:
3465      return createCXString("SEHTryStmt");
3466  case CXCursor_SEHExceptStmt:
3467      return createCXString("SEHExceptStmt");
3468  case CXCursor_SEHFinallyStmt:
3469      return createCXString("SEHFinallyStmt");
3470  case CXCursor_NullStmt:
3471      return createCXString("NullStmt");
3472  case CXCursor_InvalidFile:
3473      return createCXString("InvalidFile");
3474  case CXCursor_InvalidCode:
3475    return createCXString("InvalidCode");
3476  case CXCursor_NoDeclFound:
3477      return createCXString("NoDeclFound");
3478  case CXCursor_NotImplemented:
3479      return createCXString("NotImplemented");
3480  case CXCursor_TranslationUnit:
3481      return createCXString("TranslationUnit");
3482  case CXCursor_UnexposedAttr:
3483      return createCXString("UnexposedAttr");
3484  case CXCursor_IBActionAttr:
3485      return createCXString("attribute(ibaction)");
3486  case CXCursor_IBOutletAttr:
3487     return createCXString("attribute(iboutlet)");
3488  case CXCursor_IBOutletCollectionAttr:
3489      return createCXString("attribute(iboutletcollection)");
3490  case CXCursor_CXXFinalAttr:
3491      return createCXString("attribute(final)");
3492  case CXCursor_CXXOverrideAttr:
3493      return createCXString("attribute(override)");
3494  case CXCursor_AnnotateAttr:
3495    return createCXString("attribute(annotate)");
3496  case CXCursor_AsmLabelAttr:
3497    return createCXString("asm label");
3498  case CXCursor_PreprocessingDirective:
3499    return createCXString("preprocessing directive");
3500  case CXCursor_MacroDefinition:
3501    return createCXString("macro definition");
3502  case CXCursor_MacroExpansion:
3503    return createCXString("macro expansion");
3504  case CXCursor_InclusionDirective:
3505    return createCXString("inclusion directive");
3506  case CXCursor_Namespace:
3507    return createCXString("Namespace");
3508  case CXCursor_LinkageSpec:
3509    return createCXString("LinkageSpec");
3510  case CXCursor_CXXBaseSpecifier:
3511    return createCXString("C++ base class specifier");
3512  case CXCursor_Constructor:
3513    return createCXString("CXXConstructor");
3514  case CXCursor_Destructor:
3515    return createCXString("CXXDestructor");
3516  case CXCursor_ConversionFunction:
3517    return createCXString("CXXConversion");
3518  case CXCursor_TemplateTypeParameter:
3519    return createCXString("TemplateTypeParameter");
3520  case CXCursor_NonTypeTemplateParameter:
3521    return createCXString("NonTypeTemplateParameter");
3522  case CXCursor_TemplateTemplateParameter:
3523    return createCXString("TemplateTemplateParameter");
3524  case CXCursor_FunctionTemplate:
3525    return createCXString("FunctionTemplate");
3526  case CXCursor_ClassTemplate:
3527    return createCXString("ClassTemplate");
3528  case CXCursor_ClassTemplatePartialSpecialization:
3529    return createCXString("ClassTemplatePartialSpecialization");
3530  case CXCursor_NamespaceAlias:
3531    return createCXString("NamespaceAlias");
3532  case CXCursor_UsingDirective:
3533    return createCXString("UsingDirective");
3534  case CXCursor_UsingDeclaration:
3535    return createCXString("UsingDeclaration");
3536  case CXCursor_TypeAliasDecl:
3537    return createCXString("TypeAliasDecl");
3538  case CXCursor_ObjCSynthesizeDecl:
3539    return createCXString("ObjCSynthesizeDecl");
3540  case CXCursor_ObjCDynamicDecl:
3541    return createCXString("ObjCDynamicDecl");
3542  case CXCursor_CXXAccessSpecifier:
3543    return createCXString("CXXAccessSpecifier");
3544  }
3545
3546  llvm_unreachable("Unhandled CXCursorKind");
3547}
3548
3549struct GetCursorData {
3550  SourceLocation TokenBeginLoc;
3551  bool PointsAtMacroArgExpansion;
3552  CXCursor &BestCursor;
3553
3554  GetCursorData(SourceManager &SM,
3555                SourceLocation tokenBegin, CXCursor &outputCursor)
3556    : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) {
3557    PointsAtMacroArgExpansion = SM.isMacroArgExpansion(tokenBegin);
3558  }
3559};
3560
3561static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor,
3562                                                CXCursor parent,
3563                                                CXClientData client_data) {
3564  GetCursorData *Data = static_cast<GetCursorData *>(client_data);
3565  CXCursor *BestCursor = &Data->BestCursor;
3566
3567  // If we point inside a macro argument we should provide info of what the
3568  // token is so use the actual cursor, don't replace it with a macro expansion
3569  // cursor.
3570  if (cursor.kind == CXCursor_MacroExpansion && Data->PointsAtMacroArgExpansion)
3571    return CXChildVisit_Recurse;
3572
3573  if (clang_isDeclaration(cursor.kind)) {
3574    // Avoid having the implicit methods override the property decls.
3575    if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor)))
3576      if (MD->isImplicit())
3577        return CXChildVisit_Break;
3578  }
3579
3580  if (clang_isExpression(cursor.kind) &&
3581      clang_isDeclaration(BestCursor->kind)) {
3582    if (Decl *D = getCursorDecl(*BestCursor)) {
3583      // Avoid having the cursor of an expression replace the declaration cursor
3584      // when the expression source range overlaps the declaration range.
3585      // This can happen for C++ constructor expressions whose range generally
3586      // include the variable declaration, e.g.:
3587      //  MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl cursor.
3588      if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() &&
3589          D->getLocation() == Data->TokenBeginLoc)
3590        return CXChildVisit_Break;
3591    }
3592  }
3593
3594  // If our current best cursor is the construction of a temporary object,
3595  // don't replace that cursor with a type reference, because we want
3596  // clang_getCursor() to point at the constructor.
3597  if (clang_isExpression(BestCursor->kind) &&
3598      isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) &&
3599      cursor.kind == CXCursor_TypeRef) {
3600    // Keep the cursor pointing at CXXTemporaryObjectExpr but also mark it
3601    // as having the actual point on the type reference.
3602    *BestCursor = getTypeRefedCallExprCursor(*BestCursor);
3603    return CXChildVisit_Recurse;
3604  }
3605
3606  *BestCursor = cursor;
3607  return CXChildVisit_Recurse;
3608}
3609
3610CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) {
3611  if (!TU)
3612    return clang_getNullCursor();
3613
3614  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
3615  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
3616
3617  SourceLocation SLoc = cxloc::translateSourceLocation(Loc);
3618  CXCursor Result = cxcursor::getCursor(TU, SLoc);
3619
3620  bool Logging = getenv("LIBCLANG_LOGGING");
3621  if (Logging) {
3622    CXFile SearchFile;
3623    unsigned SearchLine, SearchColumn;
3624    CXFile ResultFile;
3625    unsigned ResultLine, ResultColumn;
3626    CXString SearchFileName, ResultFileName, KindSpelling, USR;
3627    const char *IsDef = clang_isCursorDefinition(Result)? " (Definition)" : "";
3628    CXSourceLocation ResultLoc = clang_getCursorLocation(Result);
3629
3630    clang_getExpansionLocation(Loc, &SearchFile, &SearchLine, &SearchColumn, 0);
3631    clang_getExpansionLocation(ResultLoc, &ResultFile, &ResultLine,
3632                               &ResultColumn, 0);
3633    SearchFileName = clang_getFileName(SearchFile);
3634    ResultFileName = clang_getFileName(ResultFile);
3635    KindSpelling = clang_getCursorKindSpelling(Result.kind);
3636    USR = clang_getCursorUSR(Result);
3637    fprintf(stderr, "clang_getCursor(%s:%d:%d) = %s(%s:%d:%d):%s%s\n",
3638            clang_getCString(SearchFileName), SearchLine, SearchColumn,
3639            clang_getCString(KindSpelling),
3640            clang_getCString(ResultFileName), ResultLine, ResultColumn,
3641            clang_getCString(USR), IsDef);
3642    clang_disposeString(SearchFileName);
3643    clang_disposeString(ResultFileName);
3644    clang_disposeString(KindSpelling);
3645    clang_disposeString(USR);
3646
3647    CXCursor Definition = clang_getCursorDefinition(Result);
3648    if (!clang_equalCursors(Definition, clang_getNullCursor())) {
3649      CXSourceLocation DefinitionLoc = clang_getCursorLocation(Definition);
3650      CXString DefinitionKindSpelling
3651                                = clang_getCursorKindSpelling(Definition.kind);
3652      CXFile DefinitionFile;
3653      unsigned DefinitionLine, DefinitionColumn;
3654      clang_getExpansionLocation(DefinitionLoc, &DefinitionFile,
3655                                 &DefinitionLine, &DefinitionColumn, 0);
3656      CXString DefinitionFileName = clang_getFileName(DefinitionFile);
3657      fprintf(stderr, "  -> %s(%s:%d:%d)\n",
3658              clang_getCString(DefinitionKindSpelling),
3659              clang_getCString(DefinitionFileName),
3660              DefinitionLine, DefinitionColumn);
3661      clang_disposeString(DefinitionFileName);
3662      clang_disposeString(DefinitionKindSpelling);
3663    }
3664  }
3665
3666  return Result;
3667}
3668
3669CXCursor clang_getNullCursor(void) {
3670  return MakeCXCursorInvalid(CXCursor_InvalidFile);
3671}
3672
3673unsigned clang_equalCursors(CXCursor X, CXCursor Y) {
3674  return X == Y;
3675}
3676
3677unsigned clang_hashCursor(CXCursor C) {
3678  unsigned Index = 0;
3679  if (clang_isExpression(C.kind) || clang_isStatement(C.kind))
3680    Index = 1;
3681
3682  return llvm::DenseMapInfo<std::pair<unsigned, void*> >::getHashValue(
3683                                        std::make_pair(C.kind, C.data[Index]));
3684}
3685
3686unsigned clang_isInvalid(enum CXCursorKind K) {
3687  return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid;
3688}
3689
3690unsigned clang_isDeclaration(enum CXCursorKind K) {
3691  return K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl;
3692}
3693
3694unsigned clang_isReference(enum CXCursorKind K) {
3695  return K >= CXCursor_FirstRef && K <= CXCursor_LastRef;
3696}
3697
3698unsigned clang_isExpression(enum CXCursorKind K) {
3699  return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr;
3700}
3701
3702unsigned clang_isStatement(enum CXCursorKind K) {
3703  return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt;
3704}
3705
3706unsigned clang_isAttribute(enum CXCursorKind K) {
3707    return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr;
3708}
3709
3710unsigned clang_isTranslationUnit(enum CXCursorKind K) {
3711  return K == CXCursor_TranslationUnit;
3712}
3713
3714unsigned clang_isPreprocessing(enum CXCursorKind K) {
3715  return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing;
3716}
3717
3718unsigned clang_isUnexposed(enum CXCursorKind K) {
3719  switch (K) {
3720    case CXCursor_UnexposedDecl:
3721    case CXCursor_UnexposedExpr:
3722    case CXCursor_UnexposedStmt:
3723    case CXCursor_UnexposedAttr:
3724      return true;
3725    default:
3726      return false;
3727  }
3728}
3729
3730CXCursorKind clang_getCursorKind(CXCursor C) {
3731  return C.kind;
3732}
3733
3734CXSourceLocation clang_getCursorLocation(CXCursor C) {
3735  if (clang_isReference(C.kind)) {
3736    switch (C.kind) {
3737    case CXCursor_ObjCSuperClassRef: {
3738      std::pair<ObjCInterfaceDecl *, SourceLocation> P
3739        = getCursorObjCSuperClassRef(C);
3740      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
3741    }
3742
3743    case CXCursor_ObjCProtocolRef: {
3744      std::pair<ObjCProtocolDecl *, SourceLocation> P
3745        = getCursorObjCProtocolRef(C);
3746      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
3747    }
3748
3749    case CXCursor_ObjCClassRef: {
3750      std::pair<ObjCInterfaceDecl *, SourceLocation> P
3751        = getCursorObjCClassRef(C);
3752      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
3753    }
3754
3755    case CXCursor_TypeRef: {
3756      std::pair<TypeDecl *, SourceLocation> P = getCursorTypeRef(C);
3757      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
3758    }
3759
3760    case CXCursor_TemplateRef: {
3761      std::pair<TemplateDecl *, SourceLocation> P = getCursorTemplateRef(C);
3762      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
3763    }
3764
3765    case CXCursor_NamespaceRef: {
3766      std::pair<NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C);
3767      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
3768    }
3769
3770    case CXCursor_MemberRef: {
3771      std::pair<FieldDecl *, SourceLocation> P = getCursorMemberRef(C);
3772      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
3773    }
3774
3775    case CXCursor_VariableRef: {
3776      std::pair<VarDecl *, SourceLocation> P = getCursorVariableRef(C);
3777      return cxloc::translateSourceLocation(P.first->getASTContext(), P.second);
3778    }
3779
3780    case CXCursor_CXXBaseSpecifier: {
3781      CXXBaseSpecifier *BaseSpec = getCursorCXXBaseSpecifier(C);
3782      if (!BaseSpec)
3783        return clang_getNullLocation();
3784
3785      if (TypeSourceInfo *TSInfo = BaseSpec->getTypeSourceInfo())
3786        return cxloc::translateSourceLocation(getCursorContext(C),
3787                                            TSInfo->getTypeLoc().getBeginLoc());
3788
3789      return cxloc::translateSourceLocation(getCursorContext(C),
3790                                        BaseSpec->getLocStart());
3791    }
3792
3793    case CXCursor_LabelRef: {
3794      std::pair<LabelStmt *, SourceLocation> P = getCursorLabelRef(C);
3795      return cxloc::translateSourceLocation(getCursorContext(C), P.second);
3796    }
3797
3798    case CXCursor_OverloadedDeclRef:
3799      return cxloc::translateSourceLocation(getCursorContext(C),
3800                                          getCursorOverloadedDeclRef(C).second);
3801
3802    default:
3803      // FIXME: Need a way to enumerate all non-reference cases.
3804      llvm_unreachable("Missed a reference kind");
3805    }
3806  }
3807
3808  if (clang_isExpression(C.kind))
3809    return cxloc::translateSourceLocation(getCursorContext(C),
3810                                   getLocationFromExpr(getCursorExpr(C)));
3811
3812  if (clang_isStatement(C.kind))
3813    return cxloc::translateSourceLocation(getCursorContext(C),
3814                                          getCursorStmt(C)->getLocStart());
3815
3816  if (C.kind == CXCursor_PreprocessingDirective) {
3817    SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin();
3818    return cxloc::translateSourceLocation(getCursorContext(C), L);
3819  }
3820
3821  if (C.kind == CXCursor_MacroExpansion) {
3822    SourceLocation L
3823      = cxcursor::getCursorMacroExpansion(C)->getSourceRange().getBegin();
3824    return cxloc::translateSourceLocation(getCursorContext(C), L);
3825  }
3826
3827  if (C.kind == CXCursor_MacroDefinition) {
3828    SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation();
3829    return cxloc::translateSourceLocation(getCursorContext(C), L);
3830  }
3831
3832  if (C.kind == CXCursor_InclusionDirective) {
3833    SourceLocation L
3834      = cxcursor::getCursorInclusionDirective(C)->getSourceRange().getBegin();
3835    return cxloc::translateSourceLocation(getCursorContext(C), L);
3836  }
3837
3838  if (C.kind < CXCursor_FirstDecl || C.kind > CXCursor_LastDecl)
3839    return clang_getNullLocation();
3840
3841  Decl *D = getCursorDecl(C);
3842  if (!D)
3843    return clang_getNullLocation();
3844
3845  SourceLocation Loc = D->getLocation();
3846  // FIXME: Multiple variables declared in a single declaration
3847  // currently lack the information needed to correctly determine their
3848  // ranges when accounting for the type-specifier.  We use context
3849  // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
3850  // and if so, whether it is the first decl.
3851  if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
3852    if (!cxcursor::isFirstInDeclGroup(C))
3853      Loc = VD->getLocation();
3854  }
3855
3856  // For ObjC methods, give the start location of the method name.
3857  if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
3858    Loc = MD->getSelectorStartLoc();
3859
3860  return cxloc::translateSourceLocation(getCursorContext(C), Loc);
3861}
3862
3863} // end extern "C"
3864
3865CXCursor cxcursor::getCursor(CXTranslationUnit TU, SourceLocation SLoc) {
3866  assert(TU);
3867
3868  // Guard against an invalid SourceLocation, or we may assert in one
3869  // of the following calls.
3870  if (SLoc.isInvalid())
3871    return clang_getNullCursor();
3872
3873  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
3874
3875  // Translate the given source location to make it point at the beginning of
3876  // the token under the cursor.
3877  SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(),
3878                                    CXXUnit->getASTContext().getLangOpts());
3879
3880  CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound);
3881  if (SLoc.isValid()) {
3882    GetCursorData ResultData(CXXUnit->getSourceManager(), SLoc, Result);
3883    CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData,
3884                            /*VisitPreprocessorLast=*/true,
3885                            /*VisitIncludedEntities=*/false,
3886                            SourceLocation(SLoc));
3887    CursorVis.visitFileRegion();
3888  }
3889
3890  return Result;
3891}
3892
3893static SourceRange getRawCursorExtent(CXCursor C) {
3894  if (clang_isReference(C.kind)) {
3895    switch (C.kind) {
3896    case CXCursor_ObjCSuperClassRef:
3897      return  getCursorObjCSuperClassRef(C).second;
3898
3899    case CXCursor_ObjCProtocolRef:
3900      return getCursorObjCProtocolRef(C).second;
3901
3902    case CXCursor_ObjCClassRef:
3903      return getCursorObjCClassRef(C).second;
3904
3905    case CXCursor_TypeRef:
3906      return getCursorTypeRef(C).second;
3907
3908    case CXCursor_TemplateRef:
3909      return getCursorTemplateRef(C).second;
3910
3911    case CXCursor_NamespaceRef:
3912      return getCursorNamespaceRef(C).second;
3913
3914    case CXCursor_MemberRef:
3915      return getCursorMemberRef(C).second;
3916
3917    case CXCursor_CXXBaseSpecifier:
3918      return getCursorCXXBaseSpecifier(C)->getSourceRange();
3919
3920    case CXCursor_LabelRef:
3921      return getCursorLabelRef(C).second;
3922
3923    case CXCursor_OverloadedDeclRef:
3924      return getCursorOverloadedDeclRef(C).second;
3925
3926    case CXCursor_VariableRef:
3927      return getCursorVariableRef(C).second;
3928
3929    default:
3930      // FIXME: Need a way to enumerate all non-reference cases.
3931      llvm_unreachable("Missed a reference kind");
3932    }
3933  }
3934
3935  if (clang_isExpression(C.kind))
3936    return getCursorExpr(C)->getSourceRange();
3937
3938  if (clang_isStatement(C.kind))
3939    return getCursorStmt(C)->getSourceRange();
3940
3941  if (clang_isAttribute(C.kind))
3942    return getCursorAttr(C)->getRange();
3943
3944  if (C.kind == CXCursor_PreprocessingDirective)
3945    return cxcursor::getCursorPreprocessingDirective(C);
3946
3947  if (C.kind == CXCursor_MacroExpansion) {
3948    ASTUnit *TU = getCursorASTUnit(C);
3949    SourceRange Range = cxcursor::getCursorMacroExpansion(C)->getSourceRange();
3950    return TU->mapRangeFromPreamble(Range);
3951  }
3952
3953  if (C.kind == CXCursor_MacroDefinition) {
3954    ASTUnit *TU = getCursorASTUnit(C);
3955    SourceRange Range = cxcursor::getCursorMacroDefinition(C)->getSourceRange();
3956    return TU->mapRangeFromPreamble(Range);
3957  }
3958
3959  if (C.kind == CXCursor_InclusionDirective) {
3960    ASTUnit *TU = getCursorASTUnit(C);
3961    SourceRange Range = cxcursor::getCursorInclusionDirective(C)->getSourceRange();
3962    return TU->mapRangeFromPreamble(Range);
3963  }
3964
3965  if (C.kind == CXCursor_TranslationUnit) {
3966    ASTUnit *TU = getCursorASTUnit(C);
3967    FileID MainID = TU->getSourceManager().getMainFileID();
3968    SourceLocation Start = TU->getSourceManager().getLocForStartOfFile(MainID);
3969    SourceLocation End = TU->getSourceManager().getLocForEndOfFile(MainID);
3970    return SourceRange(Start, End);
3971  }
3972
3973  if (C.kind >= CXCursor_FirstDecl && C.kind <= CXCursor_LastDecl) {
3974    Decl *D = cxcursor::getCursorDecl(C);
3975    if (!D)
3976      return SourceRange();
3977
3978    SourceRange R = D->getSourceRange();
3979    // FIXME: Multiple variables declared in a single declaration
3980    // currently lack the information needed to correctly determine their
3981    // ranges when accounting for the type-specifier.  We use context
3982    // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
3983    // and if so, whether it is the first decl.
3984    if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
3985      if (!cxcursor::isFirstInDeclGroup(C))
3986        R.setBegin(VD->getLocation());
3987    }
3988    return R;
3989  }
3990  return SourceRange();
3991}
3992
3993/// \brief Retrieves the "raw" cursor extent, which is then extended to include
3994/// the decl-specifier-seq for declarations.
3995static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) {
3996  if (C.kind >= CXCursor_FirstDecl && C.kind <= CXCursor_LastDecl) {
3997    Decl *D = cxcursor::getCursorDecl(C);
3998    if (!D)
3999      return SourceRange();
4000
4001    SourceRange R = D->getSourceRange();
4002
4003    // Adjust the start of the location for declarations preceded by
4004    // declaration specifiers.
4005    SourceLocation StartLoc;
4006    if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
4007      if (TypeSourceInfo *TI = DD->getTypeSourceInfo())
4008        StartLoc = TI->getTypeLoc().getLocStart();
4009    } else if (TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) {
4010      if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo())
4011        StartLoc = TI->getTypeLoc().getLocStart();
4012    }
4013
4014    if (StartLoc.isValid() && R.getBegin().isValid() &&
4015        SrcMgr.isBeforeInTranslationUnit(StartLoc, R.getBegin()))
4016      R.setBegin(StartLoc);
4017
4018    // FIXME: Multiple variables declared in a single declaration
4019    // currently lack the information needed to correctly determine their
4020    // ranges when accounting for the type-specifier.  We use context
4021    // stored in the CXCursor to determine if the VarDecl is in a DeclGroup,
4022    // and if so, whether it is the first decl.
4023    if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
4024      if (!cxcursor::isFirstInDeclGroup(C))
4025        R.setBegin(VD->getLocation());
4026    }
4027
4028    return R;
4029  }
4030
4031  return getRawCursorExtent(C);
4032}
4033
4034extern "C" {
4035
4036CXSourceRange clang_getCursorExtent(CXCursor C) {
4037  SourceRange R = getRawCursorExtent(C);
4038  if (R.isInvalid())
4039    return clang_getNullRange();
4040
4041  return cxloc::translateSourceRange(getCursorContext(C), R);
4042}
4043
4044CXCursor clang_getCursorReferenced(CXCursor C) {
4045  if (clang_isInvalid(C.kind))
4046    return clang_getNullCursor();
4047
4048  CXTranslationUnit tu = getCursorTU(C);
4049  if (clang_isDeclaration(C.kind)) {
4050    Decl *D = getCursorDecl(C);
4051    if (!D)
4052      return clang_getNullCursor();
4053    if (UsingDecl *Using = dyn_cast<UsingDecl>(D))
4054      return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu);
4055    if (ObjCPropertyImplDecl *PropImpl =dyn_cast<ObjCPropertyImplDecl>(D))
4056      if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl())
4057        return MakeCXCursor(Property, tu);
4058
4059    return C;
4060  }
4061
4062  if (clang_isExpression(C.kind)) {
4063    Expr *E = getCursorExpr(C);
4064    Decl *D = getDeclFromExpr(E);
4065    if (D) {
4066      CXCursor declCursor = MakeCXCursor(D, tu);
4067      declCursor = getSelectorIdentifierCursor(getSelectorIdentifierIndex(C),
4068                                               declCursor);
4069      return declCursor;
4070    }
4071
4072    if (OverloadExpr *Ovl = dyn_cast_or_null<OverloadExpr>(E))
4073      return MakeCursorOverloadedDeclRef(Ovl, tu);
4074
4075    return clang_getNullCursor();
4076  }
4077
4078  if (clang_isStatement(C.kind)) {
4079    Stmt *S = getCursorStmt(C);
4080    if (GotoStmt *Goto = dyn_cast_or_null<GotoStmt>(S))
4081      if (LabelDecl *label = Goto->getLabel())
4082        if (LabelStmt *labelS = label->getStmt())
4083        return MakeCXCursor(labelS, getCursorDecl(C), tu);
4084
4085    return clang_getNullCursor();
4086  }
4087
4088  if (C.kind == CXCursor_MacroExpansion) {
4089    if (MacroDefinition *Def = getCursorMacroExpansion(C)->getDefinition())
4090      return MakeMacroDefinitionCursor(Def, tu);
4091  }
4092
4093  if (!clang_isReference(C.kind))
4094    return clang_getNullCursor();
4095
4096  switch (C.kind) {
4097    case CXCursor_ObjCSuperClassRef:
4098      return MakeCXCursor(getCursorObjCSuperClassRef(C).first, tu);
4099
4100    case CXCursor_ObjCProtocolRef: {
4101      ObjCProtocolDecl *Prot = getCursorObjCProtocolRef(C).first;
4102      if (ObjCProtocolDecl *Def = Prot->getDefinition())
4103        return MakeCXCursor(Def, tu);
4104
4105      return MakeCXCursor(Prot, tu);
4106    }
4107
4108    case CXCursor_ObjCClassRef: {
4109      ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first;
4110      if (ObjCInterfaceDecl *Def = Class->getDefinition())
4111        return MakeCXCursor(Def, tu);
4112
4113      return MakeCXCursor(Class, tu);
4114    }
4115
4116    case CXCursor_TypeRef:
4117      return MakeCXCursor(getCursorTypeRef(C).first, tu );
4118
4119    case CXCursor_TemplateRef:
4120      return MakeCXCursor(getCursorTemplateRef(C).first, tu );
4121
4122    case CXCursor_NamespaceRef:
4123      return MakeCXCursor(getCursorNamespaceRef(C).first, tu );
4124
4125    case CXCursor_MemberRef:
4126      return MakeCXCursor(getCursorMemberRef(C).first, tu );
4127
4128    case CXCursor_CXXBaseSpecifier: {
4129      CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C);
4130      return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(),
4131                                                         tu ));
4132    }
4133
4134    case CXCursor_LabelRef:
4135      // FIXME: We end up faking the "parent" declaration here because we
4136      // don't want to make CXCursor larger.
4137      return MakeCXCursor(getCursorLabelRef(C).first,
4138               static_cast<ASTUnit*>(tu->TUData)->getASTContext()
4139                          .getTranslationUnitDecl(),
4140                          tu);
4141
4142    case CXCursor_OverloadedDeclRef:
4143      return C;
4144
4145    case CXCursor_VariableRef:
4146      return MakeCXCursor(getCursorVariableRef(C).first, tu);
4147
4148    default:
4149      // We would prefer to enumerate all non-reference cursor kinds here.
4150      llvm_unreachable("Unhandled reference cursor kind");
4151  }
4152}
4153
4154CXCursor clang_getCursorDefinition(CXCursor C) {
4155  if (clang_isInvalid(C.kind))
4156    return clang_getNullCursor();
4157
4158  CXTranslationUnit TU = getCursorTU(C);
4159
4160  bool WasReference = false;
4161  if (clang_isReference(C.kind) || clang_isExpression(C.kind)) {
4162    C = clang_getCursorReferenced(C);
4163    WasReference = true;
4164  }
4165
4166  if (C.kind == CXCursor_MacroExpansion)
4167    return clang_getCursorReferenced(C);
4168
4169  if (!clang_isDeclaration(C.kind))
4170    return clang_getNullCursor();
4171
4172  Decl *D = getCursorDecl(C);
4173  if (!D)
4174    return clang_getNullCursor();
4175
4176  switch (D->getKind()) {
4177  // Declaration kinds that don't really separate the notions of
4178  // declaration and definition.
4179  case Decl::Namespace:
4180  case Decl::Typedef:
4181  case Decl::TypeAlias:
4182  case Decl::TypeAliasTemplate:
4183  case Decl::TemplateTypeParm:
4184  case Decl::EnumConstant:
4185  case Decl::Field:
4186  case Decl::IndirectField:
4187  case Decl::ObjCIvar:
4188  case Decl::ObjCAtDefsField:
4189  case Decl::ImplicitParam:
4190  case Decl::ParmVar:
4191  case Decl::NonTypeTemplateParm:
4192  case Decl::TemplateTemplateParm:
4193  case Decl::ObjCCategoryImpl:
4194  case Decl::ObjCImplementation:
4195  case Decl::AccessSpec:
4196  case Decl::LinkageSpec:
4197  case Decl::ObjCPropertyImpl:
4198  case Decl::FileScopeAsm:
4199  case Decl::StaticAssert:
4200  case Decl::Block:
4201  case Decl::Label:  // FIXME: Is this right??
4202  case Decl::ClassScopeFunctionSpecialization:
4203  case Decl::Import:
4204    return C;
4205
4206  // Declaration kinds that don't make any sense here, but are
4207  // nonetheless harmless.
4208  case Decl::TranslationUnit:
4209    break;
4210
4211  // Declaration kinds for which the definition is not resolvable.
4212  case Decl::UnresolvedUsingTypename:
4213  case Decl::UnresolvedUsingValue:
4214    break;
4215
4216  case Decl::UsingDirective:
4217    return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(),
4218                        TU);
4219
4220  case Decl::NamespaceAlias:
4221    return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), TU);
4222
4223  case Decl::Enum:
4224  case Decl::Record:
4225  case Decl::CXXRecord:
4226  case Decl::ClassTemplateSpecialization:
4227  case Decl::ClassTemplatePartialSpecialization:
4228    if (TagDecl *Def = cast<TagDecl>(D)->getDefinition())
4229      return MakeCXCursor(Def, TU);
4230    return clang_getNullCursor();
4231
4232  case Decl::Function:
4233  case Decl::CXXMethod:
4234  case Decl::CXXConstructor:
4235  case Decl::CXXDestructor:
4236  case Decl::CXXConversion: {
4237    const FunctionDecl *Def = 0;
4238    if (cast<FunctionDecl>(D)->getBody(Def))
4239      return MakeCXCursor(const_cast<FunctionDecl *>(Def), TU);
4240    return clang_getNullCursor();
4241  }
4242
4243  case Decl::Var: {
4244    // Ask the variable if it has a definition.
4245    if (VarDecl *Def = cast<VarDecl>(D)->getDefinition())
4246      return MakeCXCursor(Def, TU);
4247    return clang_getNullCursor();
4248  }
4249
4250  case Decl::FunctionTemplate: {
4251    const FunctionDecl *Def = 0;
4252    if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def))
4253      return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU);
4254    return clang_getNullCursor();
4255  }
4256
4257  case Decl::ClassTemplate: {
4258    if (RecordDecl *Def = cast<ClassTemplateDecl>(D)->getTemplatedDecl()
4259                                                            ->getDefinition())
4260      return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(),
4261                          TU);
4262    return clang_getNullCursor();
4263  }
4264
4265  case Decl::Using:
4266    return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D),
4267                                       D->getLocation(), TU);
4268
4269  case Decl::UsingShadow:
4270    return clang_getCursorDefinition(
4271                       MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(),
4272                                    TU));
4273
4274  case Decl::ObjCMethod: {
4275    ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D);
4276    if (Method->isThisDeclarationADefinition())
4277      return C;
4278
4279    // Dig out the method definition in the associated
4280    // @implementation, if we have it.
4281    // FIXME: The ASTs should make finding the definition easier.
4282    if (ObjCInterfaceDecl *Class
4283                       = dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext()))
4284      if (ObjCImplementationDecl *ClassImpl = Class->getImplementation())
4285        if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(),
4286                                                  Method->isInstanceMethod()))
4287          if (Def->isThisDeclarationADefinition())
4288            return MakeCXCursor(Def, TU);
4289
4290    return clang_getNullCursor();
4291  }
4292
4293  case Decl::ObjCCategory:
4294    if (ObjCCategoryImplDecl *Impl
4295                               = cast<ObjCCategoryDecl>(D)->getImplementation())
4296      return MakeCXCursor(Impl, TU);
4297    return clang_getNullCursor();
4298
4299  case Decl::ObjCProtocol:
4300    if (ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(D)->getDefinition())
4301      return MakeCXCursor(Def, TU);
4302    return clang_getNullCursor();
4303
4304  case Decl::ObjCInterface: {
4305    // There are two notions of a "definition" for an Objective-C
4306    // class: the interface and its implementation. When we resolved a
4307    // reference to an Objective-C class, produce the @interface as
4308    // the definition; when we were provided with the interface,
4309    // produce the @implementation as the definition.
4310    ObjCInterfaceDecl *IFace = cast<ObjCInterfaceDecl>(D);
4311    if (WasReference) {
4312      if (ObjCInterfaceDecl *Def = IFace->getDefinition())
4313        return MakeCXCursor(Def, TU);
4314    } else if (ObjCImplementationDecl *Impl = IFace->getImplementation())
4315      return MakeCXCursor(Impl, TU);
4316    return clang_getNullCursor();
4317  }
4318
4319  case Decl::ObjCProperty:
4320    // FIXME: We don't really know where to find the
4321    // ObjCPropertyImplDecls that implement this property.
4322    return clang_getNullCursor();
4323
4324  case Decl::ObjCCompatibleAlias:
4325    if (ObjCInterfaceDecl *Class
4326          = cast<ObjCCompatibleAliasDecl>(D)->getClassInterface())
4327      if (ObjCInterfaceDecl *Def = Class->getDefinition())
4328        return MakeCXCursor(Def, TU);
4329
4330    return clang_getNullCursor();
4331
4332  case Decl::Friend:
4333    if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl())
4334      return clang_getCursorDefinition(MakeCXCursor(Friend, TU));
4335    return clang_getNullCursor();
4336
4337  case Decl::FriendTemplate:
4338    if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl())
4339      return clang_getCursorDefinition(MakeCXCursor(Friend, TU));
4340    return clang_getNullCursor();
4341  }
4342
4343  return clang_getNullCursor();
4344}
4345
4346unsigned clang_isCursorDefinition(CXCursor C) {
4347  if (!clang_isDeclaration(C.kind))
4348    return 0;
4349
4350  return clang_getCursorDefinition(C) == C;
4351}
4352
4353CXCursor clang_getCanonicalCursor(CXCursor C) {
4354  if (!clang_isDeclaration(C.kind))
4355    return C;
4356
4357  if (Decl *D = getCursorDecl(C)) {
4358    if (ObjCCategoryImplDecl *CatImplD = dyn_cast<ObjCCategoryImplDecl>(D))
4359      if (ObjCCategoryDecl *CatD = CatImplD->getCategoryDecl())
4360        return MakeCXCursor(CatD, getCursorTU(C));
4361
4362    if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
4363      if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
4364        return MakeCXCursor(IFD, getCursorTU(C));
4365
4366    return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C));
4367  }
4368
4369  return C;
4370}
4371
4372unsigned clang_getNumOverloadedDecls(CXCursor C) {
4373  if (C.kind != CXCursor_OverloadedDeclRef)
4374    return 0;
4375
4376  OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first;
4377  if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>())
4378    return E->getNumDecls();
4379
4380  if (OverloadedTemplateStorage *S
4381                              = Storage.dyn_cast<OverloadedTemplateStorage*>())
4382    return S->size();
4383
4384  Decl *D = Storage.get<Decl*>();
4385  if (UsingDecl *Using = dyn_cast<UsingDecl>(D))
4386    return Using->shadow_size();
4387
4388  return 0;
4389}
4390
4391CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) {
4392  if (cursor.kind != CXCursor_OverloadedDeclRef)
4393    return clang_getNullCursor();
4394
4395  if (index >= clang_getNumOverloadedDecls(cursor))
4396    return clang_getNullCursor();
4397
4398  CXTranslationUnit TU = getCursorTU(cursor);
4399  OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first;
4400  if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>())
4401    return MakeCXCursor(E->decls_begin()[index], TU);
4402
4403  if (OverloadedTemplateStorage *S
4404                              = Storage.dyn_cast<OverloadedTemplateStorage*>())
4405    return MakeCXCursor(S->begin()[index], TU);
4406
4407  Decl *D = Storage.get<Decl*>();
4408  if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) {
4409    // FIXME: This is, unfortunately, linear time.
4410    UsingDecl::shadow_iterator Pos = Using->shadow_begin();
4411    std::advance(Pos, index);
4412    return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU);
4413  }
4414
4415  return clang_getNullCursor();
4416}
4417
4418void clang_getDefinitionSpellingAndExtent(CXCursor C,
4419                                          const char **startBuf,
4420                                          const char **endBuf,
4421                                          unsigned *startLine,
4422                                          unsigned *startColumn,
4423                                          unsigned *endLine,
4424                                          unsigned *endColumn) {
4425  assert(getCursorDecl(C) && "CXCursor has null decl");
4426  NamedDecl *ND = static_cast<NamedDecl *>(getCursorDecl(C));
4427  FunctionDecl *FD = dyn_cast<FunctionDecl>(ND);
4428  CompoundStmt *Body = dyn_cast<CompoundStmt>(FD->getBody());
4429
4430  SourceManager &SM = FD->getASTContext().getSourceManager();
4431  *startBuf = SM.getCharacterData(Body->getLBracLoc());
4432  *endBuf = SM.getCharacterData(Body->getRBracLoc());
4433  *startLine = SM.getSpellingLineNumber(Body->getLBracLoc());
4434  *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc());
4435  *endLine = SM.getSpellingLineNumber(Body->getRBracLoc());
4436  *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc());
4437}
4438
4439
4440CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags,
4441                                                unsigned PieceIndex) {
4442  RefNamePieces Pieces;
4443
4444  switch (C.kind) {
4445  case CXCursor_MemberRefExpr:
4446    if (MemberExpr *E = dyn_cast<MemberExpr>(getCursorExpr(C)))
4447      Pieces = buildPieces(NameFlags, true, E->getMemberNameInfo(),
4448                           E->getQualifierLoc().getSourceRange());
4449    break;
4450
4451  case CXCursor_DeclRefExpr:
4452    if (DeclRefExpr *E = dyn_cast<DeclRefExpr>(getCursorExpr(C)))
4453      Pieces = buildPieces(NameFlags, false, E->getNameInfo(),
4454                           E->getQualifierLoc().getSourceRange(),
4455                           E->getOptionalExplicitTemplateArgs());
4456    break;
4457
4458  case CXCursor_CallExpr:
4459    if (CXXOperatorCallExpr *OCE =
4460        dyn_cast<CXXOperatorCallExpr>(getCursorExpr(C))) {
4461      Expr *Callee = OCE->getCallee();
4462      if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee))
4463        Callee = ICE->getSubExpr();
4464
4465      if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee))
4466        Pieces = buildPieces(NameFlags, false, DRE->getNameInfo(),
4467                             DRE->getQualifierLoc().getSourceRange());
4468    }
4469    break;
4470
4471  default:
4472    break;
4473  }
4474
4475  if (Pieces.empty()) {
4476    if (PieceIndex == 0)
4477      return clang_getCursorExtent(C);
4478  } else if (PieceIndex < Pieces.size()) {
4479      SourceRange R = Pieces[PieceIndex];
4480      if (R.isValid())
4481        return cxloc::translateSourceRange(getCursorContext(C), R);
4482  }
4483
4484  return clang_getNullRange();
4485}
4486
4487void clang_enableStackTraces(void) {
4488  llvm::sys::PrintStackTraceOnErrorSignal();
4489}
4490
4491void clang_executeOnThread(void (*fn)(void*), void *user_data,
4492                           unsigned stack_size) {
4493  llvm::llvm_execute_on_thread(fn, user_data, stack_size);
4494}
4495
4496} // end: extern "C"
4497
4498//===----------------------------------------------------------------------===//
4499// Token-based Operations.
4500//===----------------------------------------------------------------------===//
4501
4502/* CXToken layout:
4503 *   int_data[0]: a CXTokenKind
4504 *   int_data[1]: starting token location
4505 *   int_data[2]: token length
4506 *   int_data[3]: reserved
4507 *   ptr_data: for identifiers and keywords, an IdentifierInfo*.
4508 *   otherwise unused.
4509 */
4510extern "C" {
4511
4512CXTokenKind clang_getTokenKind(CXToken CXTok) {
4513  return static_cast<CXTokenKind>(CXTok.int_data[0]);
4514}
4515
4516CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) {
4517  switch (clang_getTokenKind(CXTok)) {
4518  case CXToken_Identifier:
4519  case CXToken_Keyword:
4520    // We know we have an IdentifierInfo*, so use that.
4521    return createCXString(static_cast<IdentifierInfo *>(CXTok.ptr_data)
4522                            ->getNameStart());
4523
4524  case CXToken_Literal: {
4525    // We have stashed the starting pointer in the ptr_data field. Use it.
4526    const char *Text = static_cast<const char *>(CXTok.ptr_data);
4527    return createCXString(StringRef(Text, CXTok.int_data[2]));
4528  }
4529
4530  case CXToken_Punctuation:
4531  case CXToken_Comment:
4532    break;
4533  }
4534
4535  // We have to find the starting buffer pointer the hard way, by
4536  // deconstructing the source location.
4537  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
4538  if (!CXXUnit)
4539    return createCXString("");
4540
4541  SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]);
4542  std::pair<FileID, unsigned> LocInfo
4543    = CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc);
4544  bool Invalid = false;
4545  StringRef Buffer
4546    = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid);
4547  if (Invalid)
4548    return createCXString("");
4549
4550  return createCXString(Buffer.substr(LocInfo.second, CXTok.int_data[2]));
4551}
4552
4553CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) {
4554  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
4555  if (!CXXUnit)
4556    return clang_getNullLocation();
4557
4558  return cxloc::translateSourceLocation(CXXUnit->getASTContext(),
4559                        SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
4560}
4561
4562CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) {
4563  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
4564  if (!CXXUnit)
4565    return clang_getNullRange();
4566
4567  return cxloc::translateSourceRange(CXXUnit->getASTContext(),
4568                        SourceLocation::getFromRawEncoding(CXTok.int_data[1]));
4569}
4570
4571static void getTokens(ASTUnit *CXXUnit, SourceRange Range,
4572                      SmallVectorImpl<CXToken> &CXTokens) {
4573  SourceManager &SourceMgr = CXXUnit->getSourceManager();
4574  std::pair<FileID, unsigned> BeginLocInfo
4575    = SourceMgr.getDecomposedLoc(Range.getBegin());
4576  std::pair<FileID, unsigned> EndLocInfo
4577    = SourceMgr.getDecomposedLoc(Range.getEnd());
4578
4579  // Cannot tokenize across files.
4580  if (BeginLocInfo.first != EndLocInfo.first)
4581    return;
4582
4583  // Create a lexer
4584  bool Invalid = false;
4585  StringRef Buffer
4586    = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
4587  if (Invalid)
4588    return;
4589
4590  Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
4591            CXXUnit->getASTContext().getLangOpts(),
4592            Buffer.begin(), Buffer.data() + BeginLocInfo.second, Buffer.end());
4593  Lex.SetCommentRetentionState(true);
4594
4595  // Lex tokens until we hit the end of the range.
4596  const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second;
4597  Token Tok;
4598  bool previousWasAt = false;
4599  do {
4600    // Lex the next token
4601    Lex.LexFromRawLexer(Tok);
4602    if (Tok.is(tok::eof))
4603      break;
4604
4605    // Initialize the CXToken.
4606    CXToken CXTok;
4607
4608    //   - Common fields
4609    CXTok.int_data[1] = Tok.getLocation().getRawEncoding();
4610    CXTok.int_data[2] = Tok.getLength();
4611    CXTok.int_data[3] = 0;
4612
4613    //   - Kind-specific fields
4614    if (Tok.isLiteral()) {
4615      CXTok.int_data[0] = CXToken_Literal;
4616      CXTok.ptr_data = (void *)Tok.getLiteralData();
4617    } else if (Tok.is(tok::raw_identifier)) {
4618      // Lookup the identifier to determine whether we have a keyword.
4619      IdentifierInfo *II
4620        = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok);
4621
4622      if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) {
4623        CXTok.int_data[0] = CXToken_Keyword;
4624      }
4625      else {
4626        CXTok.int_data[0] = Tok.is(tok::identifier)
4627          ? CXToken_Identifier
4628          : CXToken_Keyword;
4629      }
4630      CXTok.ptr_data = II;
4631    } else if (Tok.is(tok::comment)) {
4632      CXTok.int_data[0] = CXToken_Comment;
4633      CXTok.ptr_data = 0;
4634    } else {
4635      CXTok.int_data[0] = CXToken_Punctuation;
4636      CXTok.ptr_data = 0;
4637    }
4638    CXTokens.push_back(CXTok);
4639    previousWasAt = Tok.is(tok::at);
4640  } while (Lex.getBufferLocation() <= EffectiveBufferEnd);
4641}
4642
4643void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range,
4644                    CXToken **Tokens, unsigned *NumTokens) {
4645  if (Tokens)
4646    *Tokens = 0;
4647  if (NumTokens)
4648    *NumTokens = 0;
4649
4650  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
4651  if (!CXXUnit || !Tokens || !NumTokens)
4652    return;
4653
4654  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
4655
4656  SourceRange R = cxloc::translateCXSourceRange(Range);
4657  if (R.isInvalid())
4658    return;
4659
4660  SmallVector<CXToken, 32> CXTokens;
4661  getTokens(CXXUnit, R, CXTokens);
4662
4663  if (CXTokens.empty())
4664    return;
4665
4666  *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size());
4667  memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size());
4668  *NumTokens = CXTokens.size();
4669}
4670
4671void clang_disposeTokens(CXTranslationUnit TU,
4672                         CXToken *Tokens, unsigned NumTokens) {
4673  free(Tokens);
4674}
4675
4676} // end: extern "C"
4677
4678//===----------------------------------------------------------------------===//
4679// Token annotation APIs.
4680//===----------------------------------------------------------------------===//
4681
4682typedef llvm::DenseMap<unsigned, CXCursor> AnnotateTokensData;
4683static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
4684                                                     CXCursor parent,
4685                                                     CXClientData client_data);
4686namespace {
4687class AnnotateTokensWorker {
4688  AnnotateTokensData &Annotated;
4689  CXToken *Tokens;
4690  CXCursor *Cursors;
4691  unsigned NumTokens;
4692  unsigned TokIdx;
4693  unsigned PreprocessingTokIdx;
4694  CursorVisitor AnnotateVis;
4695  SourceManager &SrcMgr;
4696  bool HasContextSensitiveKeywords;
4697
4698  bool MoreTokens() const { return TokIdx < NumTokens; }
4699  unsigned NextToken() const { return TokIdx; }
4700  void AdvanceToken() { ++TokIdx; }
4701  SourceLocation GetTokenLoc(unsigned tokI) {
4702    return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]);
4703  }
4704  bool isFunctionMacroToken(unsigned tokI) const {
4705    return Tokens[tokI].int_data[3] != 0;
4706  }
4707  SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const {
4708    return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[3]);
4709  }
4710
4711  void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange);
4712  void annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult,
4713                                             SourceRange);
4714
4715public:
4716  AnnotateTokensWorker(AnnotateTokensData &annotated,
4717                       CXToken *tokens, CXCursor *cursors, unsigned numTokens,
4718                       CXTranslationUnit tu, SourceRange RegionOfInterest)
4719    : Annotated(annotated), Tokens(tokens), Cursors(cursors),
4720      NumTokens(numTokens), TokIdx(0), PreprocessingTokIdx(0),
4721      AnnotateVis(tu,
4722                  AnnotateTokensVisitor, this,
4723                  /*VisitPreprocessorLast=*/true,
4724                  /*VisitIncludedEntities=*/false,
4725                  RegionOfInterest),
4726      SrcMgr(static_cast<ASTUnit*>(tu->TUData)->getSourceManager()),
4727      HasContextSensitiveKeywords(false) { }
4728
4729  void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); }
4730  enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent);
4731  void AnnotateTokens();
4732
4733  /// \brief Determine whether the annotator saw any cursors that have
4734  /// context-sensitive keywords.
4735  bool hasContextSensitiveKeywords() const {
4736    return HasContextSensitiveKeywords;
4737  }
4738};
4739}
4740
4741void AnnotateTokensWorker::AnnotateTokens() {
4742  // Walk the AST within the region of interest, annotating tokens
4743  // along the way.
4744  AnnotateVis.visitFileRegion();
4745
4746  for (unsigned I = 0 ; I < TokIdx ; ++I) {
4747    AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]);
4748    if (Pos != Annotated.end() &&
4749        (clang_isInvalid(Cursors[I].kind) ||
4750         Pos->second.kind != CXCursor_PreprocessingDirective))
4751      Cursors[I] = Pos->second;
4752  }
4753
4754  // Finish up annotating any tokens left.
4755  if (!MoreTokens())
4756    return;
4757
4758  const CXCursor &C = clang_getNullCursor();
4759  for (unsigned I = TokIdx ; I < NumTokens ; ++I) {
4760    if (I < PreprocessingTokIdx && clang_isPreprocessing(Cursors[I].kind))
4761      continue;
4762
4763    AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]);
4764    Cursors[I] = (Pos == Annotated.end()) ? C : Pos->second;
4765  }
4766}
4767
4768/// \brief It annotates and advances tokens with a cursor until the comparison
4769//// between the cursor location and the source range is the same as
4770/// \arg compResult.
4771///
4772/// Pass RangeBefore to annotate tokens with a cursor until a range is reached.
4773/// Pass RangeOverlap to annotate tokens inside a range.
4774void AnnotateTokensWorker::annotateAndAdvanceTokens(CXCursor updateC,
4775                                               RangeComparisonResult compResult,
4776                                               SourceRange range) {
4777  while (MoreTokens()) {
4778    const unsigned I = NextToken();
4779    if (isFunctionMacroToken(I))
4780      return annotateAndAdvanceFunctionMacroTokens(updateC, compResult, range);
4781
4782    SourceLocation TokLoc = GetTokenLoc(I);
4783    if (LocationCompare(SrcMgr, TokLoc, range) == compResult) {
4784      Cursors[I] = updateC;
4785      AdvanceToken();
4786      continue;
4787    }
4788    break;
4789  }
4790}
4791
4792/// \brief Special annotation handling for macro argument tokens.
4793void AnnotateTokensWorker::annotateAndAdvanceFunctionMacroTokens(
4794                                               CXCursor updateC,
4795                                               RangeComparisonResult compResult,
4796                                               SourceRange range) {
4797  assert(MoreTokens());
4798  assert(isFunctionMacroToken(NextToken()) &&
4799         "Should be called only for macro arg tokens");
4800
4801  // This works differently than annotateAndAdvanceTokens; because expanded
4802  // macro arguments can have arbitrary translation-unit source order, we do not
4803  // advance the token index one by one until a token fails the range test.
4804  // We only advance once past all of the macro arg tokens if all of them
4805  // pass the range test. If one of them fails we keep the token index pointing
4806  // at the start of the macro arg tokens so that the failing token will be
4807  // annotated by a subsequent annotation try.
4808
4809  bool atLeastOneCompFail = false;
4810
4811  unsigned I = NextToken();
4812  for (; I < NumTokens && isFunctionMacroToken(I); ++I) {
4813    SourceLocation TokLoc = getFunctionMacroTokenLoc(I);
4814    if (TokLoc.isFileID())
4815      continue; // not macro arg token, it's parens or comma.
4816    if (LocationCompare(SrcMgr, TokLoc, range) == compResult) {
4817      if (clang_isInvalid(clang_getCursorKind(Cursors[I])))
4818        Cursors[I] = updateC;
4819    } else
4820      atLeastOneCompFail = true;
4821  }
4822
4823  if (!atLeastOneCompFail)
4824    TokIdx = I; // All of the tokens were handled, advance beyond all of them.
4825}
4826
4827enum CXChildVisitResult
4828AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) {
4829  CXSourceLocation Loc = clang_getCursorLocation(cursor);
4830  SourceRange cursorRange = getRawCursorExtent(cursor);
4831  if (cursorRange.isInvalid())
4832    return CXChildVisit_Recurse;
4833
4834  if (!HasContextSensitiveKeywords) {
4835    // Objective-C properties can have context-sensitive keywords.
4836    if (cursor.kind == CXCursor_ObjCPropertyDecl) {
4837      if (ObjCPropertyDecl *Property
4838                  = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(cursor)))
4839        HasContextSensitiveKeywords = Property->getPropertyAttributesAsWritten() != 0;
4840    }
4841    // Objective-C methods can have context-sensitive keywords.
4842    else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl ||
4843             cursor.kind == CXCursor_ObjCClassMethodDecl) {
4844      if (ObjCMethodDecl *Method
4845            = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) {
4846        if (Method->getObjCDeclQualifier())
4847          HasContextSensitiveKeywords = true;
4848        else {
4849          for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
4850                                           PEnd = Method->param_end();
4851               P != PEnd; ++P) {
4852            if ((*P)->getObjCDeclQualifier()) {
4853              HasContextSensitiveKeywords = true;
4854              break;
4855            }
4856          }
4857        }
4858      }
4859    }
4860    // C++ methods can have context-sensitive keywords.
4861    else if (cursor.kind == CXCursor_CXXMethod) {
4862      if (CXXMethodDecl *Method
4863                  = dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(cursor))) {
4864        if (Method->hasAttr<FinalAttr>() || Method->hasAttr<OverrideAttr>())
4865          HasContextSensitiveKeywords = true;
4866      }
4867    }
4868    // C++ classes can have context-sensitive keywords.
4869    else if (cursor.kind == CXCursor_StructDecl ||
4870             cursor.kind == CXCursor_ClassDecl ||
4871             cursor.kind == CXCursor_ClassTemplate ||
4872             cursor.kind == CXCursor_ClassTemplatePartialSpecialization) {
4873      if (Decl *D = getCursorDecl(cursor))
4874        if (D->hasAttr<FinalAttr>())
4875          HasContextSensitiveKeywords = true;
4876    }
4877  }
4878
4879  if (clang_isPreprocessing(cursor.kind)) {
4880    // For macro expansions, just note where the beginning of the macro
4881    // expansion occurs.
4882    if (cursor.kind == CXCursor_MacroExpansion) {
4883      Annotated[Loc.int_data] = cursor;
4884      return CXChildVisit_Recurse;
4885    }
4886
4887    // Items in the preprocessing record are kept separate from items in
4888    // declarations, so we keep a separate token index.
4889    unsigned SavedTokIdx = TokIdx;
4890    TokIdx = PreprocessingTokIdx;
4891
4892    // Skip tokens up until we catch up to the beginning of the preprocessing
4893    // entry.
4894    while (MoreTokens()) {
4895      const unsigned I = NextToken();
4896      SourceLocation TokLoc = GetTokenLoc(I);
4897      switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
4898      case RangeBefore:
4899        AdvanceToken();
4900        continue;
4901      case RangeAfter:
4902      case RangeOverlap:
4903        break;
4904      }
4905      break;
4906    }
4907
4908    // Look at all of the tokens within this range.
4909    while (MoreTokens()) {
4910      const unsigned I = NextToken();
4911      SourceLocation TokLoc = GetTokenLoc(I);
4912      switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) {
4913      case RangeBefore:
4914        llvm_unreachable("Infeasible");
4915      case RangeAfter:
4916        break;
4917      case RangeOverlap:
4918        Cursors[I] = cursor;
4919        AdvanceToken();
4920        continue;
4921      }
4922      break;
4923    }
4924
4925    // Save the preprocessing token index; restore the non-preprocessing
4926    // token index.
4927    PreprocessingTokIdx = TokIdx;
4928    TokIdx = SavedTokIdx;
4929    return CXChildVisit_Recurse;
4930  }
4931
4932  if (cursorRange.isInvalid())
4933    return CXChildVisit_Continue;
4934
4935  SourceLocation L = SourceLocation::getFromRawEncoding(Loc.int_data);
4936
4937  // Adjust the annotated range based specific declarations.
4938  const enum CXCursorKind cursorK = clang_getCursorKind(cursor);
4939  if (cursorK >= CXCursor_FirstDecl && cursorK <= CXCursor_LastDecl) {
4940    Decl *D = cxcursor::getCursorDecl(cursor);
4941
4942    SourceLocation StartLoc;
4943    if (const DeclaratorDecl *DD = dyn_cast_or_null<DeclaratorDecl>(D)) {
4944      if (TypeSourceInfo *TI = DD->getTypeSourceInfo())
4945        StartLoc = TI->getTypeLoc().getLocStart();
4946    } else if (TypedefDecl *Typedef = dyn_cast_or_null<TypedefDecl>(D)) {
4947      if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo())
4948        StartLoc = TI->getTypeLoc().getLocStart();
4949    }
4950
4951    if (StartLoc.isValid() && L.isValid() &&
4952        SrcMgr.isBeforeInTranslationUnit(StartLoc, L))
4953      cursorRange.setBegin(StartLoc);
4954  }
4955
4956  // If the location of the cursor occurs within a macro instantiation, record
4957  // the spelling location of the cursor in our annotation map.  We can then
4958  // paper over the token labelings during a post-processing step to try and
4959  // get cursor mappings for tokens that are the *arguments* of a macro
4960  // instantiation.
4961  if (L.isMacroID()) {
4962    unsigned rawEncoding = SrcMgr.getSpellingLoc(L).getRawEncoding();
4963    // Only invalidate the old annotation if it isn't part of a preprocessing
4964    // directive.  Here we assume that the default construction of CXCursor
4965    // results in CXCursor.kind being an initialized value (i.e., 0).  If
4966    // this isn't the case, we can fix by doing lookup + insertion.
4967
4968    CXCursor &oldC = Annotated[rawEncoding];
4969    if (!clang_isPreprocessing(oldC.kind))
4970      oldC = cursor;
4971  }
4972
4973  const enum CXCursorKind K = clang_getCursorKind(parent);
4974  const CXCursor updateC =
4975    (clang_isInvalid(K) || K == CXCursor_TranslationUnit)
4976     ? clang_getNullCursor() : parent;
4977
4978  annotateAndAdvanceTokens(updateC, RangeBefore, cursorRange);
4979
4980  // Avoid having the cursor of an expression "overwrite" the annotation of the
4981  // variable declaration that it belongs to.
4982  // This can happen for C++ constructor expressions whose range generally
4983  // include the variable declaration, e.g.:
4984  //  MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor.
4985  if (clang_isExpression(cursorK)) {
4986    Expr *E = getCursorExpr(cursor);
4987    if (Decl *D = getCursorParentDecl(cursor)) {
4988      const unsigned I = NextToken();
4989      if (E->getLocStart().isValid() && D->getLocation().isValid() &&
4990          E->getLocStart() == D->getLocation() &&
4991          E->getLocStart() == GetTokenLoc(I)) {
4992        Cursors[I] = updateC;
4993        AdvanceToken();
4994      }
4995    }
4996  }
4997
4998  // Visit children to get their cursor information.
4999  const unsigned BeforeChildren = NextToken();
5000  VisitChildren(cursor);
5001  const unsigned AfterChildren = NextToken();
5002
5003  // Scan the tokens that are at the end of the cursor, but are not captured
5004  // but the child cursors.
5005  annotateAndAdvanceTokens(cursor, RangeOverlap, cursorRange);
5006
5007  // Scan the tokens that are at the beginning of the cursor, but are not
5008  // capture by the child cursors.
5009  for (unsigned I = BeforeChildren; I != AfterChildren; ++I) {
5010    if (!clang_isInvalid(clang_getCursorKind(Cursors[I])))
5011      break;
5012
5013    Cursors[I] = cursor;
5014  }
5015
5016  return CXChildVisit_Continue;
5017}
5018
5019static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor,
5020                                                     CXCursor parent,
5021                                                     CXClientData client_data) {
5022  return static_cast<AnnotateTokensWorker*>(client_data)->Visit(cursor, parent);
5023}
5024
5025namespace {
5026
5027/// \brief Uses the macro expansions in the preprocessing record to find
5028/// and mark tokens that are macro arguments. This info is used by the
5029/// AnnotateTokensWorker.
5030class MarkMacroArgTokensVisitor {
5031  SourceManager &SM;
5032  CXToken *Tokens;
5033  unsigned NumTokens;
5034  unsigned CurIdx;
5035
5036public:
5037  MarkMacroArgTokensVisitor(SourceManager &SM,
5038                            CXToken *tokens, unsigned numTokens)
5039    : SM(SM), Tokens(tokens), NumTokens(numTokens), CurIdx(0) { }
5040
5041  CXChildVisitResult visit(CXCursor cursor, CXCursor parent) {
5042    if (cursor.kind != CXCursor_MacroExpansion)
5043      return CXChildVisit_Continue;
5044
5045    SourceRange macroRange = getCursorMacroExpansion(cursor)->getSourceRange();
5046    if (macroRange.getBegin() == macroRange.getEnd())
5047      return CXChildVisit_Continue; // it's not a function macro.
5048
5049    for (; CurIdx < NumTokens; ++CurIdx) {
5050      if (!SM.isBeforeInTranslationUnit(getTokenLoc(CurIdx),
5051                                        macroRange.getBegin()))
5052        break;
5053    }
5054
5055    if (CurIdx == NumTokens)
5056      return CXChildVisit_Break;
5057
5058    for (; CurIdx < NumTokens; ++CurIdx) {
5059      SourceLocation tokLoc = getTokenLoc(CurIdx);
5060      if (!SM.isBeforeInTranslationUnit(tokLoc, macroRange.getEnd()))
5061        break;
5062
5063      setFunctionMacroTokenLoc(CurIdx, SM.getMacroArgExpandedLocation(tokLoc));
5064    }
5065
5066    if (CurIdx == NumTokens)
5067      return CXChildVisit_Break;
5068
5069    return CXChildVisit_Continue;
5070  }
5071
5072private:
5073  SourceLocation getTokenLoc(unsigned tokI) {
5074    return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]);
5075  }
5076
5077  void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) {
5078    // The third field is reserved and currently not used. Use it here
5079    // to mark macro arg expanded tokens with their expanded locations.
5080    Tokens[tokI].int_data[3] = loc.getRawEncoding();
5081  }
5082};
5083
5084} // end anonymous namespace
5085
5086static CXChildVisitResult
5087MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent,
5088                                  CXClientData client_data) {
5089  return static_cast<MarkMacroArgTokensVisitor*>(client_data)->visit(cursor,
5090                                                                     parent);
5091}
5092
5093namespace {
5094  struct clang_annotateTokens_Data {
5095    CXTranslationUnit TU;
5096    ASTUnit *CXXUnit;
5097    CXToken *Tokens;
5098    unsigned NumTokens;
5099    CXCursor *Cursors;
5100  };
5101}
5102
5103static void annotatePreprocessorTokens(CXTranslationUnit TU,
5104                                       SourceRange RegionOfInterest,
5105                                       AnnotateTokensData &Annotated) {
5106  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
5107
5108  SourceManager &SourceMgr = CXXUnit->getSourceManager();
5109  std::pair<FileID, unsigned> BeginLocInfo
5110    = SourceMgr.getDecomposedLoc(RegionOfInterest.getBegin());
5111  std::pair<FileID, unsigned> EndLocInfo
5112    = SourceMgr.getDecomposedLoc(RegionOfInterest.getEnd());
5113
5114  if (BeginLocInfo.first != EndLocInfo.first)
5115    return;
5116
5117  StringRef Buffer;
5118  bool Invalid = false;
5119  Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid);
5120  if (Buffer.empty() || Invalid)
5121    return;
5122
5123  Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first),
5124            CXXUnit->getASTContext().getLangOpts(),
5125            Buffer.begin(), Buffer.data() + BeginLocInfo.second,
5126            Buffer.end());
5127  Lex.SetCommentRetentionState(true);
5128
5129  // Lex tokens in raw mode until we hit the end of the range, to avoid
5130  // entering #includes or expanding macros.
5131  while (true) {
5132    Token Tok;
5133    Lex.LexFromRawLexer(Tok);
5134
5135  reprocess:
5136    if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) {
5137      // We have found a preprocessing directive. Gobble it up so that we
5138      // don't see it while preprocessing these tokens later, but keep track
5139      // of all of the token locations inside this preprocessing directive so
5140      // that we can annotate them appropriately.
5141      //
5142      // FIXME: Some simple tests here could identify macro definitions and
5143      // #undefs, to provide specific cursor kinds for those.
5144      SmallVector<SourceLocation, 32> Locations;
5145      do {
5146        Locations.push_back(Tok.getLocation());
5147        Lex.LexFromRawLexer(Tok);
5148      } while (!Tok.isAtStartOfLine() && !Tok.is(tok::eof));
5149
5150      using namespace cxcursor;
5151      CXCursor Cursor
5152      = MakePreprocessingDirectiveCursor(SourceRange(Locations.front(),
5153                                                     Locations.back()),
5154                                         TU);
5155      for (unsigned I = 0, N = Locations.size(); I != N; ++I) {
5156        Annotated[Locations[I].getRawEncoding()] = Cursor;
5157      }
5158
5159      if (Tok.isAtStartOfLine())
5160        goto reprocess;
5161
5162      continue;
5163    }
5164
5165    if (Tok.is(tok::eof))
5166      break;
5167  }
5168}
5169
5170// This gets run a separate thread to avoid stack blowout.
5171static void clang_annotateTokensImpl(void *UserData) {
5172  CXTranslationUnit TU = ((clang_annotateTokens_Data*)UserData)->TU;
5173  ASTUnit *CXXUnit = ((clang_annotateTokens_Data*)UserData)->CXXUnit;
5174  CXToken *Tokens = ((clang_annotateTokens_Data*)UserData)->Tokens;
5175  const unsigned NumTokens = ((clang_annotateTokens_Data*)UserData)->NumTokens;
5176  CXCursor *Cursors = ((clang_annotateTokens_Data*)UserData)->Cursors;
5177
5178  CIndexer *CXXIdx = (CIndexer*)TU->CIdx;
5179  if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
5180    setThreadBackgroundPriority();
5181
5182  // Determine the region of interest, which contains all of the tokens.
5183  SourceRange RegionOfInterest;
5184  RegionOfInterest.setBegin(
5185    cxloc::translateSourceLocation(clang_getTokenLocation(TU, Tokens[0])));
5186  RegionOfInterest.setEnd(
5187    cxloc::translateSourceLocation(clang_getTokenLocation(TU,
5188                                                         Tokens[NumTokens-1])));
5189
5190  // A mapping from the source locations found when re-lexing or traversing the
5191  // region of interest to the corresponding cursors.
5192  AnnotateTokensData Annotated;
5193
5194  // Relex the tokens within the source range to look for preprocessing
5195  // directives.
5196  annotatePreprocessorTokens(TU, RegionOfInterest, Annotated);
5197
5198  if (CXXUnit->getPreprocessor().getPreprocessingRecord()) {
5199    // Search and mark tokens that are macro argument expansions.
5200    MarkMacroArgTokensVisitor Visitor(CXXUnit->getSourceManager(),
5201                                      Tokens, NumTokens);
5202    CursorVisitor MacroArgMarker(TU,
5203                                 MarkMacroArgTokensVisitorDelegate, &Visitor,
5204                                 /*VisitPreprocessorLast=*/true,
5205                                 /*VisitIncludedEntities=*/false,
5206                                 RegionOfInterest);
5207    MacroArgMarker.visitPreprocessedEntitiesInRegion();
5208  }
5209
5210  // Annotate all of the source locations in the region of interest that map to
5211  // a specific cursor.
5212  AnnotateTokensWorker W(Annotated, Tokens, Cursors, NumTokens,
5213                         TU, RegionOfInterest);
5214
5215  // FIXME: We use a ridiculous stack size here because the data-recursion
5216  // algorithm uses a large stack frame than the non-data recursive version,
5217  // and AnnotationTokensWorker currently transforms the data-recursion
5218  // algorithm back into a traditional recursion by explicitly calling
5219  // VisitChildren().  We will need to remove this explicit recursive call.
5220  W.AnnotateTokens();
5221
5222  // If we ran into any entities that involve context-sensitive keywords,
5223  // take another pass through the tokens to mark them as such.
5224  if (W.hasContextSensitiveKeywords()) {
5225    for (unsigned I = 0; I != NumTokens; ++I) {
5226      if (clang_getTokenKind(Tokens[I]) != CXToken_Identifier)
5227        continue;
5228
5229      if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) {
5230        IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data);
5231        if (ObjCPropertyDecl *Property
5232            = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(Cursors[I]))) {
5233          if (Property->getPropertyAttributesAsWritten() != 0 &&
5234              llvm::StringSwitch<bool>(II->getName())
5235              .Case("readonly", true)
5236              .Case("assign", true)
5237              .Case("unsafe_unretained", true)
5238              .Case("readwrite", true)
5239              .Case("retain", true)
5240              .Case("copy", true)
5241              .Case("nonatomic", true)
5242              .Case("atomic", true)
5243              .Case("getter", true)
5244              .Case("setter", true)
5245              .Case("strong", true)
5246              .Case("weak", true)
5247              .Default(false))
5248            Tokens[I].int_data[0] = CXToken_Keyword;
5249        }
5250        continue;
5251      }
5252
5253      if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl ||
5254          Cursors[I].kind == CXCursor_ObjCClassMethodDecl) {
5255        IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data);
5256        if (llvm::StringSwitch<bool>(II->getName())
5257            .Case("in", true)
5258            .Case("out", true)
5259            .Case("inout", true)
5260            .Case("oneway", true)
5261            .Case("bycopy", true)
5262            .Case("byref", true)
5263            .Default(false))
5264          Tokens[I].int_data[0] = CXToken_Keyword;
5265        continue;
5266      }
5267
5268      if (Cursors[I].kind == CXCursor_CXXFinalAttr ||
5269          Cursors[I].kind == CXCursor_CXXOverrideAttr) {
5270        Tokens[I].int_data[0] = CXToken_Keyword;
5271        continue;
5272      }
5273    }
5274  }
5275}
5276
5277extern "C" {
5278
5279void clang_annotateTokens(CXTranslationUnit TU,
5280                          CXToken *Tokens, unsigned NumTokens,
5281                          CXCursor *Cursors) {
5282
5283  if (NumTokens == 0 || !Tokens || !Cursors)
5284    return;
5285
5286  // Any token we don't specifically annotate will have a NULL cursor.
5287  CXCursor C = clang_getNullCursor();
5288  for (unsigned I = 0; I != NumTokens; ++I)
5289    Cursors[I] = C;
5290
5291  ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData);
5292  if (!CXXUnit)
5293    return;
5294
5295  ASTUnit::ConcurrencyCheck Check(*CXXUnit);
5296
5297  clang_annotateTokens_Data data = { TU, CXXUnit, Tokens, NumTokens, Cursors };
5298  llvm::CrashRecoveryContext CRC;
5299  if (!RunSafely(CRC, clang_annotateTokensImpl, &data,
5300                 GetSafetyThreadStackSize() * 2)) {
5301    fprintf(stderr, "libclang: crash detected while annotating tokens\n");
5302  }
5303}
5304
5305} // end: extern "C"
5306
5307//===----------------------------------------------------------------------===//
5308// Operations for querying linkage of a cursor.
5309//===----------------------------------------------------------------------===//
5310
5311extern "C" {
5312CXLinkageKind clang_getCursorLinkage(CXCursor cursor) {
5313  if (!clang_isDeclaration(cursor.kind))
5314    return CXLinkage_Invalid;
5315
5316  Decl *D = cxcursor::getCursorDecl(cursor);
5317  if (NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D))
5318    switch (ND->getLinkage()) {
5319      case NoLinkage: return CXLinkage_NoLinkage;
5320      case InternalLinkage: return CXLinkage_Internal;
5321      case UniqueExternalLinkage: return CXLinkage_UniqueExternal;
5322      case ExternalLinkage: return CXLinkage_External;
5323    };
5324
5325  return CXLinkage_Invalid;
5326}
5327} // end: extern "C"
5328
5329//===----------------------------------------------------------------------===//
5330// Operations for querying language of a cursor.
5331//===----------------------------------------------------------------------===//
5332
5333static CXLanguageKind getDeclLanguage(const Decl *D) {
5334  if (!D)
5335    return CXLanguage_C;
5336
5337  switch (D->getKind()) {
5338    default:
5339      break;
5340    case Decl::ImplicitParam:
5341    case Decl::ObjCAtDefsField:
5342    case Decl::ObjCCategory:
5343    case Decl::ObjCCategoryImpl:
5344    case Decl::ObjCCompatibleAlias:
5345    case Decl::ObjCImplementation:
5346    case Decl::ObjCInterface:
5347    case Decl::ObjCIvar:
5348    case Decl::ObjCMethod:
5349    case Decl::ObjCProperty:
5350    case Decl::ObjCPropertyImpl:
5351    case Decl::ObjCProtocol:
5352      return CXLanguage_ObjC;
5353    case Decl::CXXConstructor:
5354    case Decl::CXXConversion:
5355    case Decl::CXXDestructor:
5356    case Decl::CXXMethod:
5357    case Decl::CXXRecord:
5358    case Decl::ClassTemplate:
5359    case Decl::ClassTemplatePartialSpecialization:
5360    case Decl::ClassTemplateSpecialization:
5361    case Decl::Friend:
5362    case Decl::FriendTemplate:
5363    case Decl::FunctionTemplate:
5364    case Decl::LinkageSpec:
5365    case Decl::Namespace:
5366    case Decl::NamespaceAlias:
5367    case Decl::NonTypeTemplateParm:
5368    case Decl::StaticAssert:
5369    case Decl::TemplateTemplateParm:
5370    case Decl::TemplateTypeParm:
5371    case Decl::UnresolvedUsingTypename:
5372    case Decl::UnresolvedUsingValue:
5373    case Decl::Using:
5374    case Decl::UsingDirective:
5375    case Decl::UsingShadow:
5376      return CXLanguage_CPlusPlus;
5377  }
5378
5379  return CXLanguage_C;
5380}
5381
5382extern "C" {
5383
5384enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) {
5385  if (clang_isDeclaration(cursor.kind))
5386    if (Decl *D = cxcursor::getCursorDecl(cursor)) {
5387      if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted())
5388        return CXAvailability_Available;
5389
5390      switch (D->getAvailability()) {
5391      case AR_Available:
5392      case AR_NotYetIntroduced:
5393        return CXAvailability_Available;
5394
5395      case AR_Deprecated:
5396        return CXAvailability_Deprecated;
5397
5398      case AR_Unavailable:
5399        return CXAvailability_NotAvailable;
5400      }
5401    }
5402
5403  return CXAvailability_Available;
5404}
5405
5406CXLanguageKind clang_getCursorLanguage(CXCursor cursor) {
5407  if (clang_isDeclaration(cursor.kind))
5408    return getDeclLanguage(cxcursor::getCursorDecl(cursor));
5409
5410  return CXLanguage_Invalid;
5411}
5412
5413 /// \brief If the given cursor is the "templated" declaration
5414 /// descibing a class or function template, return the class or
5415 /// function template.
5416static Decl *maybeGetTemplateCursor(Decl *D) {
5417  if (!D)
5418    return 0;
5419
5420  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
5421    if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate())
5422      return FunTmpl;
5423
5424  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
5425    if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate())
5426      return ClassTmpl;
5427
5428  return D;
5429}
5430
5431CXCursor clang_getCursorSemanticParent(CXCursor cursor) {
5432  if (clang_isDeclaration(cursor.kind)) {
5433    if (Decl *D = getCursorDecl(cursor)) {
5434      DeclContext *DC = D->getDeclContext();
5435      if (!DC)
5436        return clang_getNullCursor();
5437
5438      return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)),
5439                          getCursorTU(cursor));
5440    }
5441  }
5442
5443  if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) {
5444    if (Decl *D = getCursorDecl(cursor))
5445      return MakeCXCursor(D, getCursorTU(cursor));
5446  }
5447
5448  return clang_getNullCursor();
5449}
5450
5451CXCursor clang_getCursorLexicalParent(CXCursor cursor) {
5452  if (clang_isDeclaration(cursor.kind)) {
5453    if (Decl *D = getCursorDecl(cursor)) {
5454      DeclContext *DC = D->getLexicalDeclContext();
5455      if (!DC)
5456        return clang_getNullCursor();
5457
5458      return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)),
5459                          getCursorTU(cursor));
5460    }
5461  }
5462
5463  // FIXME: Note that we can't easily compute the lexical context of a
5464  // statement or expression, so we return nothing.
5465  return clang_getNullCursor();
5466}
5467
5468void clang_getOverriddenCursors(CXCursor cursor,
5469                                CXCursor **overridden,
5470                                unsigned *num_overridden) {
5471  if (overridden)
5472    *overridden = 0;
5473  if (num_overridden)
5474    *num_overridden = 0;
5475  if (!overridden || !num_overridden)
5476    return;
5477
5478  SmallVector<CXCursor, 8> Overridden;
5479  cxcursor::getOverriddenCursors(cursor, Overridden);
5480
5481  // Don't allocate memory if we have no overriden cursors.
5482  if (Overridden.size() == 0)
5483    return;
5484
5485  *num_overridden = Overridden.size();
5486  *overridden = new CXCursor [Overridden.size()];
5487  std::copy(Overridden.begin(), Overridden.end(), *overridden);
5488}
5489
5490void clang_disposeOverriddenCursors(CXCursor *overridden) {
5491  delete [] overridden;
5492}
5493
5494CXFile clang_getIncludedFile(CXCursor cursor) {
5495  if (cursor.kind != CXCursor_InclusionDirective)
5496    return 0;
5497
5498  InclusionDirective *ID = getCursorInclusionDirective(cursor);
5499  return (void *)ID->getFile();
5500}
5501
5502} // end: extern "C"
5503
5504
5505//===----------------------------------------------------------------------===//
5506// C++ AST instrospection.
5507//===----------------------------------------------------------------------===//
5508
5509extern "C" {
5510unsigned clang_CXXMethod_isStatic(CXCursor C) {
5511  if (!clang_isDeclaration(C.kind))
5512    return 0;
5513
5514  CXXMethodDecl *Method = 0;
5515  Decl *D = cxcursor::getCursorDecl(C);
5516  if (FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(D))
5517    Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
5518  else
5519    Method = dyn_cast_or_null<CXXMethodDecl>(D);
5520  return (Method && Method->isStatic()) ? 1 : 0;
5521}
5522
5523unsigned clang_CXXMethod_isVirtual(CXCursor C) {
5524  if (!clang_isDeclaration(C.kind))
5525    return 0;
5526
5527  CXXMethodDecl *Method = 0;
5528  Decl *D = cxcursor::getCursorDecl(C);
5529  if (FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(D))
5530    Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
5531  else
5532    Method = dyn_cast_or_null<CXXMethodDecl>(D);
5533  return (Method && Method->isVirtual()) ? 1 : 0;
5534}
5535} // end: extern "C"
5536
5537//===----------------------------------------------------------------------===//
5538// Attribute introspection.
5539//===----------------------------------------------------------------------===//
5540
5541extern "C" {
5542CXType clang_getIBOutletCollectionType(CXCursor C) {
5543  if (C.kind != CXCursor_IBOutletCollectionAttr)
5544    return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C));
5545
5546  IBOutletCollectionAttr *A =
5547    cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C));
5548
5549  return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorTU(C));
5550}
5551} // end: extern "C"
5552
5553//===----------------------------------------------------------------------===//
5554// Inspecting memory usage.
5555//===----------------------------------------------------------------------===//
5556
5557typedef std::vector<CXTUResourceUsageEntry> MemUsageEntries;
5558
5559static inline void createCXTUResourceUsageEntry(MemUsageEntries &entries,
5560                                              enum CXTUResourceUsageKind k,
5561                                              unsigned long amount) {
5562  CXTUResourceUsageEntry entry = { k, amount };
5563  entries.push_back(entry);
5564}
5565
5566extern "C" {
5567
5568const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) {
5569  const char *str = "";
5570  switch (kind) {
5571    case CXTUResourceUsage_AST:
5572      str = "ASTContext: expressions, declarations, and types";
5573      break;
5574    case CXTUResourceUsage_Identifiers:
5575      str = "ASTContext: identifiers";
5576      break;
5577    case CXTUResourceUsage_Selectors:
5578      str = "ASTContext: selectors";
5579      break;
5580    case CXTUResourceUsage_GlobalCompletionResults:
5581      str = "Code completion: cached global results";
5582      break;
5583    case CXTUResourceUsage_SourceManagerContentCache:
5584      str = "SourceManager: content cache allocator";
5585      break;
5586    case CXTUResourceUsage_AST_SideTables:
5587      str = "ASTContext: side tables";
5588      break;
5589    case CXTUResourceUsage_SourceManager_Membuffer_Malloc:
5590      str = "SourceManager: malloc'ed memory buffers";
5591      break;
5592    case CXTUResourceUsage_SourceManager_Membuffer_MMap:
5593      str = "SourceManager: mmap'ed memory buffers";
5594      break;
5595    case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc:
5596      str = "ExternalASTSource: malloc'ed memory buffers";
5597      break;
5598    case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap:
5599      str = "ExternalASTSource: mmap'ed memory buffers";
5600      break;
5601    case CXTUResourceUsage_Preprocessor:
5602      str = "Preprocessor: malloc'ed memory";
5603      break;
5604    case CXTUResourceUsage_PreprocessingRecord:
5605      str = "Preprocessor: PreprocessingRecord";
5606      break;
5607    case CXTUResourceUsage_SourceManager_DataStructures:
5608      str = "SourceManager: data structures and tables";
5609      break;
5610    case CXTUResourceUsage_Preprocessor_HeaderSearch:
5611      str = "Preprocessor: header search tables";
5612      break;
5613  }
5614  return str;
5615}
5616
5617CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU) {
5618  if (!TU) {
5619    CXTUResourceUsage usage = { (void*) 0, 0, 0 };
5620    return usage;
5621  }
5622
5623  ASTUnit *astUnit = static_cast<ASTUnit*>(TU->TUData);
5624  OwningPtr<MemUsageEntries> entries(new MemUsageEntries());
5625  ASTContext &astContext = astUnit->getASTContext();
5626
5627  // How much memory is used by AST nodes and types?
5628  createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST,
5629    (unsigned long) astContext.getASTAllocatedMemory());
5630
5631  // How much memory is used by identifiers?
5632  createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Identifiers,
5633    (unsigned long) astContext.Idents.getAllocator().getTotalMemory());
5634
5635  // How much memory is used for selectors?
5636  createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Selectors,
5637    (unsigned long) astContext.Selectors.getTotalMemory());
5638
5639  // How much memory is used by ASTContext's side tables?
5640  createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST_SideTables,
5641    (unsigned long) astContext.getSideTableAllocatedMemory());
5642
5643  // How much memory is used for caching global code completion results?
5644  unsigned long completionBytes = 0;
5645  if (GlobalCodeCompletionAllocator *completionAllocator =
5646      astUnit->getCachedCompletionAllocator().getPtr()) {
5647    completionBytes = completionAllocator->getTotalMemory();
5648  }
5649  createCXTUResourceUsageEntry(*entries,
5650                               CXTUResourceUsage_GlobalCompletionResults,
5651                               completionBytes);
5652
5653  // How much memory is being used by SourceManager's content cache?
5654  createCXTUResourceUsageEntry(*entries,
5655          CXTUResourceUsage_SourceManagerContentCache,
5656          (unsigned long) astContext.getSourceManager().getContentCacheSize());
5657
5658  // How much memory is being used by the MemoryBuffer's in SourceManager?
5659  const SourceManager::MemoryBufferSizes &srcBufs =
5660    astUnit->getSourceManager().getMemoryBufferSizes();
5661
5662  createCXTUResourceUsageEntry(*entries,
5663                               CXTUResourceUsage_SourceManager_Membuffer_Malloc,
5664                               (unsigned long) srcBufs.malloc_bytes);
5665  createCXTUResourceUsageEntry(*entries,
5666                               CXTUResourceUsage_SourceManager_Membuffer_MMap,
5667                               (unsigned long) srcBufs.mmap_bytes);
5668  createCXTUResourceUsageEntry(*entries,
5669                               CXTUResourceUsage_SourceManager_DataStructures,
5670                               (unsigned long) astContext.getSourceManager()
5671                                .getDataStructureSizes());
5672
5673  // How much memory is being used by the ExternalASTSource?
5674  if (ExternalASTSource *esrc = astContext.getExternalSource()) {
5675    const ExternalASTSource::MemoryBufferSizes &sizes =
5676      esrc->getMemoryBufferSizes();
5677
5678    createCXTUResourceUsageEntry(*entries,
5679      CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc,
5680                                 (unsigned long) sizes.malloc_bytes);
5681    createCXTUResourceUsageEntry(*entries,
5682      CXTUResourceUsage_ExternalASTSource_Membuffer_MMap,
5683                                 (unsigned long) sizes.mmap_bytes);
5684  }
5685
5686  // How much memory is being used by the Preprocessor?
5687  Preprocessor &pp = astUnit->getPreprocessor();
5688  createCXTUResourceUsageEntry(*entries,
5689                               CXTUResourceUsage_Preprocessor,
5690                               pp.getTotalMemory());
5691
5692  if (PreprocessingRecord *pRec = pp.getPreprocessingRecord()) {
5693    createCXTUResourceUsageEntry(*entries,
5694                                 CXTUResourceUsage_PreprocessingRecord,
5695                                 pRec->getTotalMemory());
5696  }
5697
5698  createCXTUResourceUsageEntry(*entries,
5699                               CXTUResourceUsage_Preprocessor_HeaderSearch,
5700                               pp.getHeaderSearchInfo().getTotalMemory());
5701
5702  CXTUResourceUsage usage = { (void*) entries.get(),
5703                            (unsigned) entries->size(),
5704                            entries->size() ? &(*entries)[0] : 0 };
5705  entries.take();
5706  return usage;
5707}
5708
5709void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage) {
5710  if (usage.data)
5711    delete (MemUsageEntries*) usage.data;
5712}
5713
5714} // end extern "C"
5715
5716void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) {
5717  CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU);
5718  for (unsigned I = 0; I != Usage.numEntries; ++I)
5719    fprintf(stderr, "  %s: %lu\n",
5720            clang_getTUResourceUsageName(Usage.entries[I].kind),
5721            Usage.entries[I].amount);
5722
5723  clang_disposeCXTUResourceUsage(Usage);
5724}
5725
5726//===----------------------------------------------------------------------===//
5727// Misc. utility functions.
5728//===----------------------------------------------------------------------===//
5729
5730/// Default to using an 8 MB stack size on "safety" threads.
5731static unsigned SafetyStackThreadSize = 8 << 20;
5732
5733namespace clang {
5734
5735bool RunSafely(llvm::CrashRecoveryContext &CRC,
5736               void (*Fn)(void*), void *UserData,
5737               unsigned Size) {
5738  if (!Size)
5739    Size = GetSafetyThreadStackSize();
5740  if (Size)
5741    return CRC.RunSafelyOnThread(Fn, UserData, Size);
5742  return CRC.RunSafely(Fn, UserData);
5743}
5744
5745unsigned GetSafetyThreadStackSize() {
5746  return SafetyStackThreadSize;
5747}
5748
5749void SetSafetyThreadStackSize(unsigned Value) {
5750  SafetyStackThreadSize = Value;
5751}
5752
5753}
5754
5755void clang::setThreadBackgroundPriority() {
5756  // FIXME: Move to llvm/Support and make it cross-platform.
5757#ifdef __APPLE__
5758  setpriority(PRIO_DARWIN_THREAD, 0, PRIO_DARWIN_BG);
5759#endif
5760}
5761
5762extern "C" {
5763
5764CXString clang_getClangVersion() {
5765  return createCXString(getClangFullVersion());
5766}
5767
5768} // end: extern "C"
5769
5770