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