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