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