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