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