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