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