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