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