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