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