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