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