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