CIndex.cpp revision d7a6b1640e565487d163023a6a2e83f55476ae96
1674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen//===- CIndex.cpp - Clang-C Source Indexing Library -----------------------===// 2674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen// 3674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen// The LLVM Compiler Infrastructure 4674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen// 5674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen// This file is distributed under the University of Illinois Open Source 6674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen// License. See LICENSE.TXT for details. 7674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen// 8674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen//===----------------------------------------------------------------------===// 9674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen// 10674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen// This file implements the main API hooks in the Clang-C Source Indexing 11674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen// library. 12674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen// 13674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen//===----------------------------------------------------------------------===// 14674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 15674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "CIndexer.h" 16674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "CXComment.h" 17674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "CXCursor.h" 18674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "CXTranslationUnit.h" 19674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "CXString.h" 20674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "CXType.h" 21674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "CXSourceLocation.h" 22674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "CIndexDiagnostic.h" 23674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "CursorVisitor.h" 24674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 25674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "clang/Basic/Version.h" 26674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 27674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "clang/AST/StmtVisitor.h" 28674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "clang/Basic/Diagnostic.h" 29674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "clang/Frontend/ASTUnit.h" 30674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "clang/Frontend/CompilerInstance.h" 31674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "clang/Frontend/FrontendDiagnostic.h" 32674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "clang/Lex/Lexer.h" 33674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "clang/Lex/HeaderSearch.h" 34674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "clang/Lex/PreprocessingRecord.h" 35674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "clang/Lex/Preprocessor.h" 36674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/ADT/STLExtras.h" 37674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/ADT/Optional.h" 38674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/ADT/StringSwitch.h" 39674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/Support/SaveAndRestore.h" 40674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/Support/CrashRecoveryContext.h" 41674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/Support/PrettyStackTrace.h" 42674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/Support/MemoryBuffer.h" 43674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/Support/raw_ostream.h" 44674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/Support/Timer.h" 45674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/Support/Mutex.h" 46674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/Support/Program.h" 47674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/Support/Signals.h" 48674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/Support/Threading.h" 49674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#include "llvm/Support/Compiler.h" 50674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 51674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenusing namespace clang; 52674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenusing namespace clang::cxcursor; 53674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenusing namespace clang::cxstring; 54674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenusing namespace clang::cxtu; 55674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenusing namespace clang::cxindex; 56674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 57674060f01e9090cd21b3c5656cc3204912ad17a6Jon BoekenoogenCXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx, ASTUnit *TU) { 58674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!TU) 59674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return 0; 60674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen CXTranslationUnit D = new CXTranslationUnitImpl(); 61674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen D->CIdx = CIdx; 62674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen D->TUData = TU; 63674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen D->StringPool = createCXStringPool(); 64674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen D->Diagnostics = 0; 65674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen D->OverridenCursorsPool = createOverridenCXCursorsPool(); 66674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return D; 67674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 68674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 69674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogencxtu::CXTUOwner::~CXTUOwner() { 70674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TU) 71674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen clang_disposeTranslationUnit(TU); 72674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 73674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 74674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// \brief Compare two source ranges to determine their relative position in 75674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// the translation unit. 76674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenstatic RangeComparisonResult RangeCompare(SourceManager &SM, 77674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceRange R1, 78674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceRange R2) { 79674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen assert(R1.isValid() && "First range is invalid?"); 80674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen assert(R2.isValid() && "Second range is invalid?"); 81674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (R1.getEnd() != R2.getBegin() && 82674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SM.isBeforeInTranslationUnit(R1.getEnd(), R2.getBegin())) 83674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return RangeBefore; 84674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (R2.getEnd() != R1.getBegin() && 85674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SM.isBeforeInTranslationUnit(R2.getEnd(), R1.getBegin())) 86674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return RangeAfter; 87674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return RangeOverlap; 88674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 89674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 90674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// \brief Determine if a source location falls within, before, or after a 91674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// a given source range. 92674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenstatic RangeComparisonResult LocationCompare(SourceManager &SM, 93674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceLocation L, SourceRange R) { 94674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen assert(R.isValid() && "First range is invalid?"); 95674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen assert(L.isValid() && "Second range is invalid?"); 96674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (L == R.getBegin() || L == R.getEnd()) 97674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return RangeOverlap; 98674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (SM.isBeforeInTranslationUnit(L, R.getBegin())) 99674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return RangeBefore; 100674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (SM.isBeforeInTranslationUnit(R.getEnd(), L)) 101674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return RangeAfter; 102674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return RangeOverlap; 103674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 104674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 105674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// \brief Translate a Clang source range into a CIndex source range. 106674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// 107674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// Clang internally represents ranges where the end location points to the 108674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// start of the token at the end. However, for external clients it is more 109674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// useful to have a CXSourceRange be a proper half-open interval. This routine 110674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// does the appropriate translation. 111674060f01e9090cd21b3c5656cc3204912ad17a6Jon BoekenoogenCXSourceRange cxloc::translateSourceRange(const SourceManager &SM, 112674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen const LangOptions &LangOpts, 113674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen const CharSourceRange &R) { 114674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // We want the last character in this location, so we will adjust the 115674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // location accordingly. 116674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceLocation EndLoc = R.getEnd(); 117674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (EndLoc.isValid() && EndLoc.isMacroID() && !SM.isMacroArgExpansion(EndLoc)) 118674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen EndLoc = SM.getExpansionRange(EndLoc).second; 119674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (R.isTokenRange() && !EndLoc.isInvalid()) { 120674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen unsigned Length = Lexer::MeasureTokenLength(SM.getSpellingLoc(EndLoc), 121674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SM, LangOpts); 122674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen EndLoc = EndLoc.getLocWithOffset(Length); 123674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 124674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 125674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen CXSourceRange Result = { { (void *)&SM, (void *)&LangOpts }, 126674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen R.getBegin().getRawEncoding(), 127674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen EndLoc.getRawEncoding() }; 128674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Result; 129674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 130674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 131674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen//===----------------------------------------------------------------------===// 132674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen// Cursor visitor. 133674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen//===----------------------------------------------------------------------===// 134674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 135674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenstatic SourceRange getRawCursorExtent(CXCursor C); 136674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenstatic SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr); 137674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 138674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 139674060f01e9090cd21b3c5656cc3204912ad17a6Jon BoekenoogenRangeComparisonResult CursorVisitor::CompareRegionOfInterest(SourceRange R) { 140674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return RangeCompare(AU->getSourceManager(), R, RegionOfInterest); 141674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 142674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 143674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// \brief Visit the given cursor and, if requested by the visitor, 144674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// its children. 145674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// 146674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// \param Cursor the cursor to visit. 147674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// 148674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// \param CheckedRegionOfInterest if true, then the caller already checked 149674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// that this cursor is within the region of interest. 150674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// 151674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// \returns true if the visitation should be aborted, false if it 152674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// should continue. 153674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::Visit(CXCursor Cursor, bool CheckedRegionOfInterest) { 154674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (clang_isInvalid(Cursor.kind)) 155674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 156674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 157674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (clang_isDeclaration(Cursor.kind)) { 158674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Decl *D = getCursorDecl(Cursor); 159674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!D) { 160674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen assert(0 && "Invalid declaration cursor"); 161674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; // abort. 162674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 163674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 164674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Ignore implicit declarations, unless it's an objc method because 165674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // currently we should report implicit methods for properties when indexing. 166674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (D->isImplicit() && !isa<ObjCMethodDecl>(D)) 167674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 168674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 169674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 170674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // If we have a range of interest, and this cursor doesn't intersect with it, 171674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // we're done. 172674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (RegionOfInterest.isValid() && !CheckedRegionOfInterest) { 173674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceRange Range = getRawCursorExtent(Cursor); 174674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Range.isInvalid() || CompareRegionOfInterest(Range)) 175674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 176674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 177674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 178674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen switch (Visitor(Cursor, Parent, ClientData)) { 179674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case CXChildVisit_Break: 180674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 181674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 182674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case CXChildVisit_Continue: 183674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 184674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 185674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case CXChildVisit_Recurse: { 186674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen bool ret = VisitChildren(Cursor); 187674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (PostChildrenVisitor) 188674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (PostChildrenVisitor(Cursor, ClientData)) 189674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 190674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return ret; 191674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 192674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 193674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 194674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen llvm_unreachable("Invalid CXChildVisitResult!"); 195674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 196674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 197674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenstatic bool visitPreprocessedEntitiesInRange(SourceRange R, 198674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen PreprocessingRecord &PPRec, 199674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen CursorVisitor &Visitor) { 200674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceManager &SM = Visitor.getASTUnit()->getSourceManager(); 201674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen FileID FID; 202674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 203674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!Visitor.shouldVisitIncludedEntities()) { 204674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // If the begin/end of the range lie in the same FileID, do the optimization 205674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // where we skip preprocessed entities that do not come from the same FileID. 206674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen FID = SM.getFileID(SM.getFileLoc(R.getBegin())); 207674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (FID != SM.getFileID(SM.getFileLoc(R.getEnd()))) 208674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen FID = FileID(); 209674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 210674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 211674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator> 212674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Entities = PPRec.getPreprocessedEntitiesInRange(R); 213674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visitor.visitPreprocessedEntities(Entities.first, Entities.second, 214674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen PPRec, FID); 215674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 216674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 217674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenvoid CursorVisitor::visitFileRegion() { 218674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (RegionOfInterest.isInvalid()) 219674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return; 220674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 221674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ASTUnit *Unit = static_cast<ASTUnit *>(TU->TUData); 222674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceManager &SM = Unit->getSourceManager(); 223674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 224674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen std::pair<FileID, unsigned> 225674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Begin = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getBegin())), 226674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen End = SM.getDecomposedLoc(SM.getFileLoc(RegionOfInterest.getEnd())); 227674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 228674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (End.first != Begin.first) { 229674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // If the end does not reside in the same file, try to recover by 230674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // picking the end of the file of begin location. 231674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen End.first = Begin.first; 232674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen End.second = SM.getFileIDSize(Begin.first); 233674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 234674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 235674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen assert(Begin.first == End.first); 236674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Begin.second > End.second) 237674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return; 238674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 239674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen FileID File = Begin.first; 240674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen unsigned Offset = Begin.second; 241674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen unsigned Length = End.second - Begin.second; 242674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 243674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!VisitDeclsOnly && !VisitPreprocessorLast) 244674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (visitPreprocessedEntitiesInRegion()) 245674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return; // visitation break. 246674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 247674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen visitDeclsFromFileRegion(File, Offset, Length); 248674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 249674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!VisitDeclsOnly && VisitPreprocessorLast) 250674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen visitPreprocessedEntitiesInRegion(); 251674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 252674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 253674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenstatic bool isInLexicalContext(Decl *D, DeclContext *DC) { 254674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!DC) 255674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 256674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 257674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (DeclContext *DeclDC = D->getLexicalDeclContext(); 258674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen DeclDC; DeclDC = DeclDC->getLexicalParent()) { 259674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (DeclDC == DC) 260674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 261674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 262674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 263674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 264674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 265674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenvoid CursorVisitor::visitDeclsFromFileRegion(FileID File, 266674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen unsigned Offset, unsigned Length) { 267674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ASTUnit *Unit = static_cast<ASTUnit *>(TU->TUData); 268674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceManager &SM = Unit->getSourceManager(); 269674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceRange Range = RegionOfInterest; 270674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 271674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SmallVector<Decl *, 16> Decls; 272674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Unit->findFileRegionDecls(File, Offset, Length, Decls); 273674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 274674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // If we didn't find any file level decls for the file, try looking at the 275674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // file that it was included from. 276674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen while (Decls.empty() || Decls.front()->isTopLevelDeclInObjCContainer()) { 277674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen bool Invalid = false; 278674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen const SrcMgr::SLocEntry &SLEntry = SM.getSLocEntry(File, &Invalid); 279674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Invalid) 280674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return; 281674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 282674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceLocation Outer; 283674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (SLEntry.isFile()) 284674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Outer = SLEntry.getFile().getIncludeLoc(); 285674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen else 286674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Outer = SLEntry.getExpansion().getExpansionLocStart(); 287674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Outer.isInvalid()) 288674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return; 289674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 290674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen llvm::tie(File, Offset) = SM.getDecomposedExpansionLoc(Outer); 291674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Length = 0; 292674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Unit->findFileRegionDecls(File, Offset, Length, Decls); 293674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 294674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 295674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen assert(!Decls.empty()); 296674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 297674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen bool VisitedAtLeastOnce = false; 298674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen DeclContext *CurDC = 0; 299674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SmallVector<Decl *, 16>::iterator DIt = Decls.begin(); 300674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (SmallVector<Decl *, 16>::iterator DE = Decls.end(); DIt != DE; ++DIt) { 301674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Decl *D = *DIt; 302674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (D->getSourceRange().isInvalid()) 303674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 304674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 305674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (isInLexicalContext(D, CurDC)) 306674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 307674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 308674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen CurDC = dyn_cast<DeclContext>(D); 309674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 310674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TagDecl *TD = dyn_cast<TagDecl>(D)) 311674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!TD->isFreeStanding()) 312674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 313674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 314674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen RangeComparisonResult CompRes = RangeCompare(SM, D->getSourceRange(),Range); 315674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (CompRes == RangeBefore) 316674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 317674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (CompRes == RangeAfter) 318674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 319674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 320674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen assert(CompRes == RangeOverlap); 321674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen VisitedAtLeastOnce = true; 322674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 323674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (isa<ObjCContainerDecl>(D)) { 324674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen FileDI_current = &DIt; 325674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen FileDE_current = DE; 326674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } else { 327674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen FileDI_current = 0; 328674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 329674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 330674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true)) 331674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 332674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 333674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 334674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitedAtLeastOnce) 335674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return; 336674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 337674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // No Decls overlapped with the range. Move up the lexical context until there 338674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // is a context that contains the range or we reach the translation unit 339674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // level. 340674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen DeclContext *DC = DIt == Decls.begin() ? (*DIt)->getLexicalDeclContext() 341674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen : (*(DIt-1))->getLexicalDeclContext(); 342674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 343674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen while (DC && !DC->isTranslationUnit()) { 344674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Decl *D = cast<Decl>(DC); 345674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceRange CurDeclRange = D->getSourceRange(); 346674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (CurDeclRange.isInvalid()) 347674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 348674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 349674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (RangeCompare(SM, CurDeclRange, Range) == RangeOverlap) { 350674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Visit(MakeCXCursor(D, TU, Range), /*CheckedRegionOfInterest=*/true); 351674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 352674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 353674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 354674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen DC = D->getLexicalDeclContext(); 355674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 356674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 357674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 358674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::visitPreprocessedEntitiesInRegion() { 359674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!AU->getPreprocessor().getPreprocessingRecord()) 360674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 361674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 362674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen PreprocessingRecord &PPRec 363674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen = *AU->getPreprocessor().getPreprocessingRecord(); 364674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceManager &SM = AU->getSourceManager(); 365674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 366674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (RegionOfInterest.isValid()) { 367674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceRange MappedRange = AU->mapRangeToPreamble(RegionOfInterest); 368674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceLocation B = MappedRange.getBegin(); 369674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceLocation E = MappedRange.getEnd(); 370674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 371674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (AU->isInPreambleFileID(B)) { 372674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (SM.isLoadedSourceLocation(E)) 373674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return visitPreprocessedEntitiesInRange(SourceRange(B, E), 374674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen PPRec, *this); 375674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 376674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Beginning of range lies in the preamble but it also extends beyond 377674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // it into the main file. Split the range into 2 parts, one covering 378674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // the preamble and another covering the main file. This allows subsequent 379674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // calls to visitPreprocessedEntitiesInRange to accept a source range that 380674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // lies in the same FileID, allowing it to skip preprocessed entities that 381674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // do not come from the same FileID. 382674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen bool breaked = 383674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen visitPreprocessedEntitiesInRange( 384674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceRange(B, AU->getEndOfPreambleFileID()), 385674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen PPRec, *this); 386674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (breaked) return true; 387674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return visitPreprocessedEntitiesInRange( 388674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceRange(AU->getStartOfMainFileID(), E), 389674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen PPRec, *this); 390674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 391674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 392674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return visitPreprocessedEntitiesInRange(SourceRange(B, E), PPRec, *this); 393674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 394674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 395674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen bool OnlyLocalDecls 396674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen = !AU->isMainFileAST() && AU->getOnlyLocalDecls(); 397674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 398674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (OnlyLocalDecls) 399674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return visitPreprocessedEntities(PPRec.local_begin(), PPRec.local_end(), 400674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen PPRec); 401674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 402674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return visitPreprocessedEntities(PPRec.begin(), PPRec.end(), PPRec); 403674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 404674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 405674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogentemplate<typename InputIterator> 406674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::visitPreprocessedEntities(InputIterator First, 407674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen InputIterator Last, 408674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen PreprocessingRecord &PPRec, 409674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen FileID FID) { 410674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (; First != Last; ++First) { 411674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!FID.isInvalid() && !PPRec.isEntityInFileID(First, FID)) 412674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 413674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 414674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen PreprocessedEntity *PPE = *First; 415674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (MacroExpansion *ME = dyn_cast<MacroExpansion>(PPE)) { 416674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeMacroExpansionCursor(ME, TU))) 417674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 418674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 419674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 420674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 421674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 422674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (MacroDefinition *MD = dyn_cast<MacroDefinition>(PPE)) { 423674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeMacroDefinitionCursor(MD, TU))) 424674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 425674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 426674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 427674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 428674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 429674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (InclusionDirective *ID = dyn_cast<InclusionDirective>(PPE)) { 430674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeInclusionDirectiveCursor(ID, TU))) 431674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 432674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 433674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 434674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 435674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 436674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 437674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 438674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 439674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 440674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// \brief Visit the children of the given cursor. 441674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// 442674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// \returns true if the visitation should be aborted, false if it 443674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// should continue. 444674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitChildren(CXCursor Cursor) { 445674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (clang_isReference(Cursor.kind) && 446674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Cursor.kind != CXCursor_CXXBaseSpecifier) { 447674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // By definition, references have no children. 448674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 449674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 450674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 451674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Set the Parent field to Cursor, then back to its old value once we're 452674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // done. 453674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SetParentRAII SetParent(Parent, StmtParent, Cursor); 454674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 455674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (clang_isDeclaration(Cursor.kind)) { 456674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Decl *D = getCursorDecl(Cursor); 457674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!D) 458674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 459674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 460674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitAttributes(D) || Visit(D); 461674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 462674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 463674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (clang_isStatement(Cursor.kind)) { 464674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Stmt *S = getCursorStmt(Cursor)) 465674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(S); 466674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 467674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 468674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 469674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 470674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (clang_isExpression(Cursor.kind)) { 471674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Expr *E = getCursorExpr(Cursor)) 472674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(E); 473674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 474674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 475674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 476674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 477674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (clang_isTranslationUnit(Cursor.kind)) { 478674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen CXTranslationUnit tu = getCursorTU(Cursor); 479674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ASTUnit *CXXUnit = static_cast<ASTUnit*>(tu->TUData); 480674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 481674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen int VisitOrder[2] = { VisitPreprocessorLast, !VisitPreprocessorLast }; 482674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (unsigned I = 0; I != 2; ++I) { 483674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitOrder[I]) { 484674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!CXXUnit->isMainFileAST() && CXXUnit->getOnlyLocalDecls() && 485674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen RegionOfInterest.isInvalid()) { 486674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(), 487674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen TLEnd = CXXUnit->top_level_end(); 488674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen TL != TLEnd; ++TL) { 489674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCXCursor(*TL, tu, RegionOfInterest), true)) 490674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 491674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 492674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } else if (VisitDeclContext( 493674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen CXXUnit->getASTContext().getTranslationUnitDecl())) 494674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 495674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 496674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 497674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 498674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Walk the preprocessing record. 499674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (CXXUnit->getPreprocessor().getPreprocessingRecord()) 500674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen visitPreprocessedEntitiesInRegion(); 501674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 502674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 503674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 504674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 505674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 506674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Cursor.kind == CXCursor_CXXBaseSpecifier) { 507674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (CXXBaseSpecifier *Base = getCursorCXXBaseSpecifier(Cursor)) { 508674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TypeSourceInfo *BaseTSInfo = Base->getTypeSourceInfo()) { 509674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(BaseTSInfo->getTypeLoc()); 510674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 511674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 512674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 513674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 514674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Cursor.kind == CXCursor_IBOutletCollectionAttr) { 515674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen IBOutletCollectionAttr *A = 516674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(Cursor)); 517674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (const ObjCInterfaceType *InterT = A->getInterface()->getAs<ObjCInterfaceType>()) 518674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(cxcursor::MakeCursorObjCClassRef(InterT->getInterface(), 519674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen A->getInterfaceLoc(), TU)); 520674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 521674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 522674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Nothing to visit at the moment. 523674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 524674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 525674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 526674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitBlockDecl(BlockDecl *B) { 527674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TypeSourceInfo *TSInfo = B->getSignatureAsWritten()) 528674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(TSInfo->getTypeLoc())) 529674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 530674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 531674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Stmt *Body = B->getBody()) 532674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCXCursor(Body, StmtParent, TU, RegionOfInterest)); 533674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 534674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 535674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 536674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 537674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenllvm::Optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) { 538674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (RegionOfInterest.isValid()) { 539674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceRange Range = getFullCursorExtent(Cursor, AU->getSourceManager()); 540674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Range.isInvalid()) 541674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return llvm::Optional<bool>(); 542674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 543674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen switch (CompareRegionOfInterest(Range)) { 544674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case RangeBefore: 545674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // This declaration comes before the region of interest; skip it. 546674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return llvm::Optional<bool>(); 547674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 548674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case RangeAfter: 549674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // This declaration comes after the region of interest; we're done. 550674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 551674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 552674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case RangeOverlap: 553674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // This declaration overlaps the region of interest; visit it. 554674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 555674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 556674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 557674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 558674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 559674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 560674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitDeclContext(DeclContext *DC) { 561674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end(); 562674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 563674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: Eventually remove. This part of a hack to support proper 564674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // iteration over all Decls contained lexically within an ObjC container. 565674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SaveAndRestore<DeclContext::decl_iterator*> DI_saved(DI_current, &I); 566674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SaveAndRestore<DeclContext::decl_iterator> DE_saved(DE_current, E); 567674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 568674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for ( ; I != E; ++I) { 569674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Decl *D = *I; 570674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (D->getLexicalDeclContext() != DC) 571674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 572674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen CXCursor Cursor = MakeCXCursor(D, TU, RegionOfInterest); 573674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 574674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Ignore synthesized ivars here, otherwise if we have something like: 575674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // @synthesize prop = _prop; 576674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // and '_prop' is not declared, we will encounter a '_prop' ivar before 577674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // encountering the 'prop' synthesize declaration and we will think that 578674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // we passed the region-of-interest. 579674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (ObjCIvarDecl *ivarD = dyn_cast<ObjCIvarDecl>(D)) { 580674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (ivarD->getSynthesize()) 581674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 582674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 583674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 584674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: ObjCClassRef/ObjCProtocolRef for forward class/protocol 585674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // declarations is a mismatch with the compiler semantics. 586674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Cursor.kind == CXCursor_ObjCInterfaceDecl) { 587674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ObjCInterfaceDecl *ID = cast<ObjCInterfaceDecl>(D); 588674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!ID->isThisDeclarationADefinition()) 589674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Cursor = MakeCursorObjCClassRef(ID, ID->getLocation(), TU); 590674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 591674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } else if (Cursor.kind == CXCursor_ObjCProtocolDecl) { 592674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ObjCProtocolDecl *PD = cast<ObjCProtocolDecl>(D); 593674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!PD->isThisDeclarationADefinition()) 594674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Cursor = MakeCursorObjCProtocolRef(PD, PD->getLocation(), TU); 595674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 596674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 597674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen const llvm::Optional<bool> &V = shouldVisitCursor(Cursor); 598674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!V.hasValue()) 599674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 600674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!V.getValue()) 601674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 602674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(Cursor, true)) 603674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 604674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 605674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 606674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 607674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 608674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 609674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen llvm_unreachable("Translation units are visited directly by Visit()"); 610674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 611674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 612674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitTypeAliasDecl(TypeAliasDecl *D) { 613674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo()) 614674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(TSInfo->getTypeLoc()); 615674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 616674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 617674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 618674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 619674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitTypedefDecl(TypedefDecl *D) { 620674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TypeSourceInfo *TSInfo = D->getTypeSourceInfo()) 621674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(TSInfo->getTypeLoc()); 622674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 623674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 624674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 625674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 626674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitTagDecl(TagDecl *D) { 627674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitDeclContext(D); 628674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 629674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 630674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitClassTemplateSpecializationDecl( 631674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ClassTemplateSpecializationDecl *D) { 632674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen bool ShouldVisitBody = false; 633674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen switch (D->getSpecializationKind()) { 634674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TSK_Undeclared: 635674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TSK_ImplicitInstantiation: 636674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Nothing to visit 637674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 638674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 639674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TSK_ExplicitInstantiationDeclaration: 640674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TSK_ExplicitInstantiationDefinition: 641674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 642674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 643674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TSK_ExplicitSpecialization: 644674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ShouldVisitBody = true; 645674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 646674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 647674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 648674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit the template arguments used in the specialization. 649674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TypeSourceInfo *SpecType = D->getTypeAsWritten()) { 650674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen TypeLoc TL = SpecType->getTypeLoc(); 651674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TemplateSpecializationTypeLoc *TSTLoc 652674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen = dyn_cast<TemplateSpecializationTypeLoc>(&TL)) { 653674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (unsigned I = 0, N = TSTLoc->getNumArgs(); I != N; ++I) 654674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitTemplateArgumentLoc(TSTLoc->getArgLoc(I))) 655674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 656674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 657674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 658674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 659674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (ShouldVisitBody && VisitCXXRecordDecl(D)) 660674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 661674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 662674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 663674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 664674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 665674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitClassTemplatePartialSpecializationDecl( 666674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ClassTemplatePartialSpecializationDecl *D) { 667674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: Visit the "outer" template parameter lists on the TagDecl 668674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // before visiting these template parameters. 669674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitTemplateParameters(D->getTemplateParameters())) 670674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 671674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 672674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit the partial specialization arguments. 673674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen const TemplateArgumentLoc *TemplateArgs = D->getTemplateArgsAsWritten(); 674674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (unsigned I = 0, N = D->getNumTemplateArgsAsWritten(); I != N; ++I) 675674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitTemplateArgumentLoc(TemplateArgs[I])) 676674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 677674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 678674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitCXXRecordDecl(D); 679674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 680674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 681674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 682674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit the default argument. 683674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 684674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TypeSourceInfo *DefArg = D->getDefaultArgumentInfo()) 685674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(DefArg->getTypeLoc())) 686674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 687674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 688674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 689674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 690674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 691674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitEnumConstantDecl(EnumConstantDecl *D) { 692674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Expr *Init = D->getInitExpr()) 693674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest)); 694674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 695674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 696674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 697674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitDeclaratorDecl(DeclaratorDecl *DD) { 698674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TypeSourceInfo *TSInfo = DD->getTypeSourceInfo()) 699674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(TSInfo->getTypeLoc())) 700674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 701674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 702674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit the nested-name-specifier, if present. 703674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (NestedNameSpecifierLoc QualifierLoc = DD->getQualifierLoc()) 704674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitNestedNameSpecifierLoc(QualifierLoc)) 705674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 706674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 707674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 708674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 709674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 710674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen/// \brief Compare two base or member initializers based on their source order. 711674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenstatic int CompareCXXCtorInitializers(const void* Xp, const void *Yp) { 712674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen CXXCtorInitializer const * const *X 713674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen = static_cast<CXXCtorInitializer const * const *>(Xp); 714674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen CXXCtorInitializer const * const *Y 715674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen = static_cast<CXXCtorInitializer const * const *>(Yp); 716674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 717674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if ((*X)->getSourceOrder() < (*Y)->getSourceOrder()) 718674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return -1; 719674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen else if ((*X)->getSourceOrder() > (*Y)->getSourceOrder()) 720674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return 1; 721674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen else 722674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return 0; 723674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 724674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 725674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitFunctionDecl(FunctionDecl *ND) { 726674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TypeSourceInfo *TSInfo = ND->getTypeSourceInfo()) { 727674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit the function declaration's syntactic components in the order 728674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // written. This requires a bit of work. 729674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen TypeLoc TL = TSInfo->getTypeLoc().IgnoreParens(); 730674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen FunctionTypeLoc *FTL = dyn_cast<FunctionTypeLoc>(&TL); 731674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 732674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // If we have a function declared directly (without the use of a typedef), 733674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // visit just the return type. Otherwise, just visit the function's type 734674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // now. 735674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if ((FTL && !isa<CXXConversionDecl>(ND) && Visit(FTL->getResultLoc())) || 736674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen (!FTL && Visit(TL))) 737674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 738674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 739674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit the nested-name-specifier, if present. 740674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (NestedNameSpecifierLoc QualifierLoc = ND->getQualifierLoc()) 741674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitNestedNameSpecifierLoc(QualifierLoc)) 742674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 743674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 744674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit the declaration name. 745674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitDeclarationNameInfo(ND->getNameInfo())) 746674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 747674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 748674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: Visit explicitly-specified template arguments! 749674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 750674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit the function parameters, if we have a function type. 751674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (FTL && VisitFunctionTypeLoc(*FTL, true)) 752674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 753674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 754674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: Attributes? 755674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 756674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 757674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (ND->doesThisDeclarationHaveABody() && !ND->isLateTemplateParsed()) { 758674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ND)) { 759674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Find the initializers that were written in the source. 760674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SmallVector<CXXCtorInitializer *, 4> WrittenInits; 761674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (CXXConstructorDecl::init_iterator I = Constructor->init_begin(), 762674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen IEnd = Constructor->init_end(); 763674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen I != IEnd; ++I) { 764674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!(*I)->isWritten()) 765674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 766674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 767674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen WrittenInits.push_back(*I); 768674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 769674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 770674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Sort the initializers in source order 771674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen llvm::array_pod_sort(WrittenInits.begin(), WrittenInits.end(), 772674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen &CompareCXXCtorInitializers); 773674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 774674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit the initializers in source order 775674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (unsigned I = 0, N = WrittenInits.size(); I != N; ++I) { 776674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen CXXCtorInitializer *Init = WrittenInits[I]; 777674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Init->isAnyMemberInitializer()) { 778674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCursorMemberRef(Init->getAnyMember(), 779674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Init->getMemberLocation(), TU))) 780674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 781674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } else if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) { 782674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(TInfo->getTypeLoc())) 783674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 784674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 785674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 786674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit the initializer value. 787674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Expr *Initializer = Init->getInit()) 788674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCXCursor(Initializer, ND, TU, RegionOfInterest))) 789674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 790674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 791674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 792674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 793674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest))) 794674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 795674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 796674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 797674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 798674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 799674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 800674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitFieldDecl(FieldDecl *D) { 801674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitDeclaratorDecl(D)) 802674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 803674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 804674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Expr *BitWidth = D->getBitWidth()) 805674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCXCursor(BitWidth, StmtParent, TU, RegionOfInterest)); 806674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 807674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 808674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 809674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 810674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitVarDecl(VarDecl *D) { 811674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitDeclaratorDecl(D)) 812674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 813674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 814674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Expr *Init = D->getInit()) 815674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCXCursor(Init, StmtParent, TU, RegionOfInterest)); 816674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 817674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 818674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 819674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 820674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 821674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitDeclaratorDecl(D)) 822674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 823674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 824674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 825674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Expr *DefArg = D->getDefaultArgument()) 826674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCXCursor(DefArg, StmtParent, TU, RegionOfInterest)); 827674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 828674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 829674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 830674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 831674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 832674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: Visit the "outer" template parameter lists on the FunctionDecl 833674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // before visiting these template parameters. 834674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitTemplateParameters(D->getTemplateParameters())) 835674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 836674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 837674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitFunctionDecl(D->getTemplatedDecl()); 838674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 839674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 840674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitClassTemplateDecl(ClassTemplateDecl *D) { 841674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: Visit the "outer" template parameter lists on the TagDecl 842674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // before visiting these template parameters. 843674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitTemplateParameters(D->getTemplateParameters())) 844674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 845674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 846674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitCXXRecordDecl(D->getTemplatedDecl()); 847674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 848674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 849674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 850674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitTemplateParameters(D->getTemplateParameters())) 851674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 852674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 853674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited() && 854674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen VisitTemplateArgumentLoc(D->getDefaultArgument())) 855674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 856674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 857674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 858674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 859674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 860674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitObjCMethodDecl(ObjCMethodDecl *ND) { 861674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TypeSourceInfo *TSInfo = ND->getResultTypeSourceInfo()) 862674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(TSInfo->getTypeLoc())) 863674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 864674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 865674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (ObjCMethodDecl::param_iterator P = ND->param_begin(), 866674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen PEnd = ND->param_end(); 867674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen P != PEnd; ++P) { 868674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCXCursor(*P, TU, RegionOfInterest))) 869674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 870674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 871674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 872674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (ND->isThisDeclarationADefinition() && 873674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Visit(MakeCXCursor(ND->getBody(), StmtParent, TU, RegionOfInterest))) 874674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 875674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 876674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 877674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 878674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 879674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogentemplate <typename DeclIt> 880674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenstatic void addRangedDeclsInContainer(DeclIt *DI_current, DeclIt DE_current, 881674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceManager &SM, SourceLocation EndLoc, 882674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SmallVectorImpl<Decl *> &Decls) { 883674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen DeclIt next = *DI_current; 884674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen while (++next != DE_current) { 885674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Decl *D_next = *next; 886674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!D_next) 887674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 888674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceLocation L = D_next->getLocStart(); 889674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!L.isValid()) 890674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 891674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (SM.isBeforeInTranslationUnit(L, EndLoc)) { 892674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen *DI_current = next; 893674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Decls.push_back(D_next); 894674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 895674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 896674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 897674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 898674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 899674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 900674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogennamespace { 901674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen struct ContainerDeclsSort { 902674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceManager &SM; 903674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ContainerDeclsSort(SourceManager &sm) : SM(sm) {} 904674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen bool operator()(Decl *A, Decl *B) { 905674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceLocation L_A = A->getLocStart(); 906674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceLocation L_B = B->getLocStart(); 907674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen assert(L_A.isValid() && L_B.isValid()); 908674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return SM.isBeforeInTranslationUnit(L_A, L_B); 909674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 910674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen }; 911674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 912674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 913674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) { 914674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: Eventually convert back to just 'VisitDeclContext()'. Essentially 915674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // an @implementation can lexically contain Decls that are not properly 916674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // nested in the AST. When we identify such cases, we need to retrofit 917674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // this nesting here. 918674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!DI_current && !FileDI_current) 919674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitDeclContext(D); 920674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 921674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Scan the Decls that immediately come after the container 922674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // in the current DeclContext. If any fall within the 923674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // container's lexical region, stash them into a vector 924674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // for later processing. 925674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SmallVector<Decl *, 24> DeclsInContainer; 926674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceLocation EndLoc = D->getSourceRange().getEnd(); 927674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceManager &SM = AU->getSourceManager(); 928674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (EndLoc.isValid()) { 929674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (DI_current) { 930674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen addRangedDeclsInContainer(DI_current, DE_current, SM, EndLoc, 931674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen DeclsInContainer); 932674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } else { 933674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen addRangedDeclsInContainer(FileDI_current, FileDE_current, SM, EndLoc, 934674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen DeclsInContainer); 935674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 936674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 937674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 938674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // The common case. 939674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (DeclsInContainer.empty()) 940674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitDeclContext(D); 941674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 942674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Get all the Decls in the DeclContext, and sort them with the 943674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // additional ones we've collected. Then visit them. 944674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (DeclContext::decl_iterator I = D->decls_begin(), E = D->decls_end(); 945674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen I!=E; ++I) { 946674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Decl *subDecl = *I; 947674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!subDecl || subDecl->getLexicalDeclContext() != D || 948674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen subDecl->getLocStart().isInvalid()) 949674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 950674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen DeclsInContainer.push_back(subDecl); 951674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 952674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 953674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Now sort the Decls so that they appear in lexical order. 954674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen std::sort(DeclsInContainer.begin(), DeclsInContainer.end(), 955674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ContainerDeclsSort(SM)); 956674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 957674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Now visit the decls. 958674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (SmallVectorImpl<Decl*>::iterator I = DeclsInContainer.begin(), 959674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen E = DeclsInContainer.end(); I != E; ++I) { 960674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen CXCursor Cursor = MakeCXCursor(*I, TU, RegionOfInterest); 961674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen const llvm::Optional<bool> &V = shouldVisitCursor(Cursor); 962674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!V.hasValue()) 963674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen continue; 964674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!V.getValue()) 965674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 966674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(Cursor, true)) 967674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 968674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 969674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 970674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 971674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 972674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitObjCCategoryDecl(ObjCCategoryDecl *ND) { 973674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCursorObjCClassRef(ND->getClassInterface(), ND->getLocation(), 974674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen TU))) 975674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 976674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 977674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ObjCCategoryDecl::protocol_loc_iterator PL = ND->protocol_loc_begin(); 978674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (ObjCCategoryDecl::protocol_iterator I = ND->protocol_begin(), 979674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen E = ND->protocol_end(); I != E; ++I, ++PL) 980674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 981674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 982674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 983674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitObjCContainerDecl(ND); 984674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 985674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 986674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) { 987674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!PID->isThisDeclarationADefinition()) 988674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorObjCProtocolRef(PID, PID->getLocation(), TU)); 989674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 990674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ObjCProtocolDecl::protocol_loc_iterator PL = PID->protocol_loc_begin(); 991674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (ObjCProtocolDecl::protocol_iterator I = PID->protocol_begin(), 992674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen E = PID->protocol_end(); I != E; ++I, ++PL) 993674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 994674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 995674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 996674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitObjCContainerDecl(PID); 997674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 998674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 999674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitObjCPropertyDecl(ObjCPropertyDecl *PD) { 1000674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (PD->getTypeSourceInfo() && Visit(PD->getTypeSourceInfo()->getTypeLoc())) 1001674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1002674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1003674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: This implements a workaround with @property declarations also being 1004674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // installed in the DeclContext for the @interface. Eventually this code 1005674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // should be removed. 1006674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ObjCCategoryDecl *CDecl = dyn_cast<ObjCCategoryDecl>(PD->getDeclContext()); 1007674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!CDecl || !CDecl->IsClassExtension()) 1008674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1009674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1010674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ObjCInterfaceDecl *ID = CDecl->getClassInterface(); 1011674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!ID) 1012674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1013674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1014674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen IdentifierInfo *PropertyId = PD->getIdentifier(); 1015674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ObjCPropertyDecl *prevDecl = 1016674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(ID), PropertyId); 1017674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1018674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!prevDecl) 1019674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1020674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1021674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit synthesized methods since they will be skipped when visiting 1022674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // the @interface. 1023674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (ObjCMethodDecl *MD = prevDecl->getGetterMethodDecl()) 1024674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (MD->isSynthesized() && MD->getLexicalDeclContext() == CDecl) 1025674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCXCursor(MD, TU, RegionOfInterest))) 1026674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1027674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1028674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (ObjCMethodDecl *MD = prevDecl->getSetterMethodDecl()) 1029674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (MD->isSynthesized() && MD->getLexicalDeclContext() == CDecl) 1030674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCXCursor(MD, TU, RegionOfInterest))) 1031674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1032674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1033674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1034674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1035674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1036674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 1037674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!D->isThisDeclarationADefinition()) { 1038674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Forward declaration is treated like a reference. 1039674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorObjCClassRef(D, D->getLocation(), TU)); 1040674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 1041674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1042674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Issue callbacks for super class. 1043674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (D->getSuperClass() && 1044674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(), 1045674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen D->getSuperClassLoc(), 1046674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen TU))) 1047674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1048674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1049674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen ObjCInterfaceDecl::protocol_loc_iterator PL = D->protocol_loc_begin(); 1050674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (ObjCInterfaceDecl::protocol_iterator I = D->protocol_begin(), 1051674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen E = D->protocol_end(); I != E; ++I, ++PL) 1052674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCursorObjCProtocolRef(*I, *PL, TU))) 1053674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1054674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1055674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitObjCContainerDecl(D); 1056674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1057674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1058674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitObjCImplDecl(ObjCImplDecl *D) { 1059674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitObjCContainerDecl(D); 1060674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1061674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1062674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 1063674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // 'ID' could be null when dealing with invalid code. 1064674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (ObjCInterfaceDecl *ID = D->getClassInterface()) 1065674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCursorObjCClassRef(ID, D->getLocation(), TU))) 1066674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1067674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1068674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitObjCImplDecl(D); 1069674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1070674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1071674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 1072674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#if 0 1073674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Issue callbacks for super class. 1074674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: No source location information! 1075674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (D->getSuperClass() && 1076674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Visit(MakeCursorObjCSuperClassRef(D->getSuperClass(), 1077674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen D->getSuperClassLoc(), 1078674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen TU))) 1079674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1080674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen#endif 1081674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1082674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitObjCImplDecl(D); 1083674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1084674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1085674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PD) { 1086674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (ObjCIvarDecl *Ivar = PD->getPropertyIvarDecl()) 1087674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (PD->isIvarNameSpecified()) 1088674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorMemberRef(Ivar, PD->getPropertyIvarDeclLoc(), TU)); 1089674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1090674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1091674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1092674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1093674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitNamespaceDecl(NamespaceDecl *D) { 1094674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitDeclContext(D); 1095674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1096674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1097674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 1098674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit nested-name-specifier. 1099674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1100674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1101674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1102674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1103674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorNamespaceRef(D->getAliasedNamespace(), 1104674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen D->getTargetNameLoc(), TU)); 1105674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1106674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1107674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitUsingDecl(UsingDecl *D) { 1108674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit nested-name-specifier. 1109674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) { 1110674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1111674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1112674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 1113674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1114674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCursorOverloadedDeclRef(D, D->getLocation(), TU))) 1115674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1116674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1117674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitDeclarationNameInfo(D->getNameInfo()); 1118674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1119674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1120674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 1121674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit nested-name-specifier. 1122674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1123674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1124674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1125674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1126674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorNamespaceRef(D->getNominatedNamespaceAsWritten(), 1127674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen D->getIdentLocation(), TU)); 1128674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1129674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1130674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 1131674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit nested-name-specifier. 1132674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) { 1133674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1134674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1135674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 1136674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1137674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitDeclarationNameInfo(D->getNameInfo()); 1138674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1139674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1140674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitUnresolvedUsingTypenameDecl( 1141674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen UnresolvedUsingTypenameDecl *D) { 1142674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit nested-name-specifier. 1143674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1144674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1145674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1146674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1147674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1148674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1149674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1150674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitDeclarationNameInfo(DeclarationNameInfo Name) { 1151674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen switch (Name.getName().getNameKind()) { 1152674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case clang::DeclarationName::Identifier: 1153674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case clang::DeclarationName::CXXLiteralOperatorName: 1154674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case clang::DeclarationName::CXXOperatorName: 1155674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case clang::DeclarationName::CXXUsingDirective: 1156674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1157674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1158674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case clang::DeclarationName::CXXConstructorName: 1159674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case clang::DeclarationName::CXXDestructorName: 1160674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case clang::DeclarationName::CXXConversionFunctionName: 1161674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TypeSourceInfo *TSInfo = Name.getNamedTypeInfo()) 1162674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(TSInfo->getTypeLoc()); 1163674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1164674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1165674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case clang::DeclarationName::ObjCZeroArgSelector: 1166674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case clang::DeclarationName::ObjCOneArgSelector: 1167674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case clang::DeclarationName::ObjCMultiArgSelector: 1168674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: Per-identifier location info? 1169674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1170674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 1171674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1172674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen llvm_unreachable("Invalid DeclarationName::Kind!"); 1173674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1174674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1175674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitNestedNameSpecifier(NestedNameSpecifier *NNS, 1176674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SourceRange Range) { 1177674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: This whole routine is a hack to work around the lack of proper 1178674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // source information in nested-name-specifiers (PR5791). Since we do have 1179674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // a beginning source location, we can visit the first component of the 1180674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // nested-name-specifier, if it's a single-token component. 1181674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!NNS) 1182674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1183674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1184674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Get the first component in the nested-name-specifier. 1185674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen while (NestedNameSpecifier *Prefix = NNS->getPrefix()) 1186674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen NNS = Prefix; 1187674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1188674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen switch (NNS->getKind()) { 1189674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::Namespace: 1190674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), Range.getBegin(), 1191674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen TU)); 1192674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1193674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::NamespaceAlias: 1194674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 1195674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Range.getBegin(), TU)); 1196674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1197674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::TypeSpec: { 1198674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // If the type has a form where we know that the beginning of the source 1199674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // range matches up with a reference cursor. Visit the appropriate reference 1200674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // cursor. 1201674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen const Type *T = NNS->getAsType(); 1202674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (const TypedefType *Typedef = dyn_cast<TypedefType>(T)) 1203674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorTypeRef(Typedef->getDecl(), Range.getBegin(), TU)); 1204674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (const TagType *Tag = dyn_cast<TagType>(T)) 1205674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorTypeRef(Tag->getDecl(), Range.getBegin(), TU)); 1206674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (const TemplateSpecializationType *TST 1207674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen = dyn_cast<TemplateSpecializationType>(T)) 1208674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return VisitTemplateName(TST->getTemplateName(), Range.getBegin()); 1209674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 1210674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 1211674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1212674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::TypeSpecWithTemplate: 1213674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::Global: 1214674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::Identifier: 1215674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 1216674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 1217674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1218674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1219674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1220674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1221674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool 1222674060f01e9090cd21b3c5656cc3204912ad17a6Jon BoekenoogenCursorVisitor::VisitNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) { 1223674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen SmallVector<NestedNameSpecifierLoc, 4> Qualifiers; 1224674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (; Qualifier; Qualifier = Qualifier.getPrefix()) 1225674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Qualifiers.push_back(Qualifier); 1226674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1227674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen while (!Qualifiers.empty()) { 1228674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen NestedNameSpecifierLoc Q = Qualifiers.pop_back_val(); 1229674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen NestedNameSpecifier *NNS = Q.getNestedNameSpecifier(); 1230674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen switch (NNS->getKind()) { 1231674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::Namespace: 1232674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespace(), 1233674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Q.getLocalBeginLoc(), 1234674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen TU))) 1235674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1236674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1237674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 1238674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1239674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::NamespaceAlias: 1240674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCursorNamespaceRef(NNS->getAsNamespaceAlias(), 1241674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Q.getLocalBeginLoc(), 1242674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen TU))) 1243674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1244674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1245674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 1246674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1247674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::TypeSpec: 1248674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::TypeSpecWithTemplate: 1249674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(Q.getTypeLoc())) 1250674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1251674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1252674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 1253674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1254674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::Global: 1255674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case NestedNameSpecifier::Identifier: 1256674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen break; 1257674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 1258674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 1259674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1260674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1261674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1262674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1263674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitTemplateParameters( 1264674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen const TemplateParameterList *Params) { 1265674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (!Params) 1266674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1267674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1268674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen for (TemplateParameterList::const_iterator P = Params->begin(), 1269674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen PEnd = Params->end(); 1270674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen P != PEnd; ++P) { 1271674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCXCursor(*P, TU, RegionOfInterest))) 1272674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1273674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 1274674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1275674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1276674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1277674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1278674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) { 1279674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen switch (Name.getKind()) { 1280674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TemplateName::Template: 1281674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU)); 1282674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1283674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TemplateName::OverloadedTemplate: 1284674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // Visit the overloaded template set. 1285674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU))) 1286674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return true; 1287674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1288674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1289674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1290674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TemplateName::DependentTemplate: 1291674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: Visit nested-name-specifier. 1292674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1293674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1294674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TemplateName::QualifiedTemplate: 1295674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen // FIXME: Visit nested-name-specifier. 1296674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorTemplateRef( 1297674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Name.getAsQualifiedTemplateName()->getDecl(), 1298674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Loc, TU)); 1299674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1300674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TemplateName::SubstTemplateTemplateParm: 1301674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorTemplateRef( 1302674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Name.getAsSubstTemplateTemplateParm()->getParameter(), 1303674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Loc, TU)); 1304674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1305674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TemplateName::SubstTemplateTemplateParmPack: 1306674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCursorTemplateRef( 1307674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(), 1308674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen Loc, TU)); 1309674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen } 1310674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1311674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen llvm_unreachable("Invalid TemplateName::Kind!"); 1312674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen} 1313674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1314674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogenbool CursorVisitor::VisitTemplateArgumentLoc(const TemplateArgumentLoc &TAL) { 1315674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen switch (TAL.getArgument().getKind()) { 1316674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TemplateArgument::Null: 1317674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TemplateArgument::Integral: 1318674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TemplateArgument::Pack: 1319674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1320674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1321674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TemplateArgument::Type: 1322674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (TypeSourceInfo *TSInfo = TAL.getTypeSourceInfo()) 1323674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(TSInfo->getTypeLoc()); 1324674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return false; 1325674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen 1326674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen case TemplateArgument::Declaration: 1327674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen if (Expr *E = TAL.getSourceDeclExpression()) 1328674060f01e9090cd21b3c5656cc3204912ad17a6Jon Boekenoogen return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1329 return false; 1330 1331 case TemplateArgument::NullPtr: 1332 if (Expr *E = TAL.getSourceNullPtrExpression()) 1333 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1334 return false; 1335 1336 case TemplateArgument::Expression: 1337 if (Expr *E = TAL.getSourceExpression()) 1338 return Visit(MakeCXCursor(E, StmtParent, TU, RegionOfInterest)); 1339 return false; 1340 1341 case TemplateArgument::Template: 1342 case TemplateArgument::TemplateExpansion: 1343 if (VisitNestedNameSpecifierLoc(TAL.getTemplateQualifierLoc())) 1344 return true; 1345 1346 return VisitTemplateName(TAL.getArgument().getAsTemplateOrTemplatePattern(), 1347 TAL.getTemplateNameLoc()); 1348 } 1349 1350 llvm_unreachable("Invalid TemplateArgument::Kind!"); 1351} 1352 1353bool CursorVisitor::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 1354 return VisitDeclContext(D); 1355} 1356 1357bool CursorVisitor::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 1358 return Visit(TL.getUnqualifiedLoc()); 1359} 1360 1361bool CursorVisitor::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 1362 ASTContext &Context = AU->getASTContext(); 1363 1364 // Some builtin types (such as Objective-C's "id", "sel", and 1365 // "Class") have associated declarations. Create cursors for those. 1366 QualType VisitType; 1367 switch (TL.getTypePtr()->getKind()) { 1368 1369 case BuiltinType::Void: 1370 case BuiltinType::NullPtr: 1371 case BuiltinType::Dependent: 1372#define BUILTIN_TYPE(Id, SingletonId) 1373#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: 1374#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: 1375#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id: 1376#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id: 1377#include "clang/AST/BuiltinTypes.def" 1378 break; 1379 1380 case BuiltinType::ObjCId: 1381 VisitType = Context.getObjCIdType(); 1382 break; 1383 1384 case BuiltinType::ObjCClass: 1385 VisitType = Context.getObjCClassType(); 1386 break; 1387 1388 case BuiltinType::ObjCSel: 1389 VisitType = Context.getObjCSelType(); 1390 break; 1391 } 1392 1393 if (!VisitType.isNull()) { 1394 if (const TypedefType *Typedef = VisitType->getAs<TypedefType>()) 1395 return Visit(MakeCursorTypeRef(Typedef->getDecl(), TL.getBuiltinLoc(), 1396 TU)); 1397 } 1398 1399 return false; 1400} 1401 1402bool CursorVisitor::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 1403 return Visit(MakeCursorTypeRef(TL.getTypedefNameDecl(), TL.getNameLoc(), TU)); 1404} 1405 1406bool CursorVisitor::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 1407 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1408} 1409 1410bool CursorVisitor::VisitTagTypeLoc(TagTypeLoc TL) { 1411 if (TL.isDefinition()) 1412 return Visit(MakeCXCursor(TL.getDecl(), TU, RegionOfInterest)); 1413 1414 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1415} 1416 1417bool CursorVisitor::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 1418 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1419} 1420 1421bool CursorVisitor::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 1422 if (Visit(MakeCursorObjCClassRef(TL.getIFaceDecl(), TL.getNameLoc(), TU))) 1423 return true; 1424 1425 return false; 1426} 1427 1428bool CursorVisitor::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 1429 if (TL.hasBaseTypeAsWritten() && Visit(TL.getBaseLoc())) 1430 return true; 1431 1432 for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) { 1433 if (Visit(MakeCursorObjCProtocolRef(TL.getProtocol(I), TL.getProtocolLoc(I), 1434 TU))) 1435 return true; 1436 } 1437 1438 return false; 1439} 1440 1441bool CursorVisitor::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 1442 return Visit(TL.getPointeeLoc()); 1443} 1444 1445bool CursorVisitor::VisitParenTypeLoc(ParenTypeLoc TL) { 1446 return Visit(TL.getInnerLoc()); 1447} 1448 1449bool CursorVisitor::VisitPointerTypeLoc(PointerTypeLoc TL) { 1450 return Visit(TL.getPointeeLoc()); 1451} 1452 1453bool CursorVisitor::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 1454 return Visit(TL.getPointeeLoc()); 1455} 1456 1457bool CursorVisitor::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 1458 return Visit(TL.getPointeeLoc()); 1459} 1460 1461bool CursorVisitor::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 1462 return Visit(TL.getPointeeLoc()); 1463} 1464 1465bool CursorVisitor::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 1466 return Visit(TL.getPointeeLoc()); 1467} 1468 1469bool CursorVisitor::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 1470 return Visit(TL.getModifiedLoc()); 1471} 1472 1473bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL, 1474 bool SkipResultType) { 1475 if (!SkipResultType && Visit(TL.getResultLoc())) 1476 return true; 1477 1478 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1479 if (Decl *D = TL.getArg(I)) 1480 if (Visit(MakeCXCursor(D, TU, RegionOfInterest))) 1481 return true; 1482 1483 return false; 1484} 1485 1486bool CursorVisitor::VisitArrayTypeLoc(ArrayTypeLoc TL) { 1487 if (Visit(TL.getElementLoc())) 1488 return true; 1489 1490 if (Expr *Size = TL.getSizeExpr()) 1491 return Visit(MakeCXCursor(Size, StmtParent, TU, RegionOfInterest)); 1492 1493 return false; 1494} 1495 1496bool CursorVisitor::VisitTemplateSpecializationTypeLoc( 1497 TemplateSpecializationTypeLoc TL) { 1498 // Visit the template name. 1499 if (VisitTemplateName(TL.getTypePtr()->getTemplateName(), 1500 TL.getTemplateNameLoc())) 1501 return true; 1502 1503 // Visit the template arguments. 1504 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1505 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1506 return true; 1507 1508 return false; 1509} 1510 1511bool CursorVisitor::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 1512 return Visit(MakeCXCursor(TL.getUnderlyingExpr(), StmtParent, TU)); 1513} 1514 1515bool CursorVisitor::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 1516 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo()) 1517 return Visit(TSInfo->getTypeLoc()); 1518 1519 return false; 1520} 1521 1522bool CursorVisitor::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 1523 if (TypeSourceInfo *TSInfo = TL.getUnderlyingTInfo()) 1524 return Visit(TSInfo->getTypeLoc()); 1525 1526 return false; 1527} 1528 1529bool CursorVisitor::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 1530 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1531 return true; 1532 1533 return false; 1534} 1535 1536bool CursorVisitor::VisitDependentTemplateSpecializationTypeLoc( 1537 DependentTemplateSpecializationTypeLoc TL) { 1538 // Visit the nested-name-specifier, if there is one. 1539 if (TL.getQualifierLoc() && 1540 VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1541 return true; 1542 1543 // Visit the template arguments. 1544 for (unsigned I = 0, N = TL.getNumArgs(); I != N; ++I) 1545 if (VisitTemplateArgumentLoc(TL.getArgLoc(I))) 1546 return true; 1547 1548 return false; 1549} 1550 1551bool CursorVisitor::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 1552 if (VisitNestedNameSpecifierLoc(TL.getQualifierLoc())) 1553 return true; 1554 1555 return Visit(TL.getNamedTypeLoc()); 1556} 1557 1558bool CursorVisitor::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 1559 return Visit(TL.getPatternLoc()); 1560} 1561 1562bool CursorVisitor::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 1563 if (Expr *E = TL.getUnderlyingExpr()) 1564 return Visit(MakeCXCursor(E, StmtParent, TU)); 1565 1566 return false; 1567} 1568 1569bool CursorVisitor::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 1570 return Visit(MakeCursorTypeRef(TL.getDecl(), TL.getNameLoc(), TU)); 1571} 1572 1573bool CursorVisitor::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 1574 return Visit(TL.getValueLoc()); 1575} 1576 1577#define DEFAULT_TYPELOC_IMPL(CLASS, PARENT) \ 1578bool CursorVisitor::Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { \ 1579 return Visit##PARENT##Loc(TL); \ 1580} 1581 1582DEFAULT_TYPELOC_IMPL(Complex, Type) 1583DEFAULT_TYPELOC_IMPL(ConstantArray, ArrayType) 1584DEFAULT_TYPELOC_IMPL(IncompleteArray, ArrayType) 1585DEFAULT_TYPELOC_IMPL(VariableArray, ArrayType) 1586DEFAULT_TYPELOC_IMPL(DependentSizedArray, ArrayType) 1587DEFAULT_TYPELOC_IMPL(DependentSizedExtVector, Type) 1588DEFAULT_TYPELOC_IMPL(Vector, Type) 1589DEFAULT_TYPELOC_IMPL(ExtVector, VectorType) 1590DEFAULT_TYPELOC_IMPL(FunctionProto, FunctionType) 1591DEFAULT_TYPELOC_IMPL(FunctionNoProto, FunctionType) 1592DEFAULT_TYPELOC_IMPL(Record, TagType) 1593DEFAULT_TYPELOC_IMPL(Enum, TagType) 1594DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParm, Type) 1595DEFAULT_TYPELOC_IMPL(SubstTemplateTypeParmPack, Type) 1596DEFAULT_TYPELOC_IMPL(Auto, Type) 1597 1598bool CursorVisitor::VisitCXXRecordDecl(CXXRecordDecl *D) { 1599 // Visit the nested-name-specifier, if present. 1600 if (NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc()) 1601 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 1602 return true; 1603 1604 if (D->isCompleteDefinition()) { 1605 for (CXXRecordDecl::base_class_iterator I = D->bases_begin(), 1606 E = D->bases_end(); I != E; ++I) { 1607 if (Visit(cxcursor::MakeCursorCXXBaseSpecifier(I, TU))) 1608 return true; 1609 } 1610 } 1611 1612 return VisitTagDecl(D); 1613} 1614 1615bool CursorVisitor::VisitAttributes(Decl *D) { 1616 for (AttrVec::const_iterator i = D->attr_begin(), e = D->attr_end(); 1617 i != e; ++i) 1618 if (Visit(MakeCXCursor(*i, D, TU))) 1619 return true; 1620 1621 return false; 1622} 1623 1624//===----------------------------------------------------------------------===// 1625// Data-recursive visitor methods. 1626//===----------------------------------------------------------------------===// 1627 1628namespace { 1629#define DEF_JOB(NAME, DATA, KIND)\ 1630class NAME : public VisitorJob {\ 1631public:\ 1632 NAME(DATA *d, CXCursor parent) : VisitorJob(parent, VisitorJob::KIND, d) {} \ 1633 static bool classof(const VisitorJob *VJ) { return VJ->getKind() == KIND; }\ 1634 DATA *get() const { return static_cast<DATA*>(data[0]); }\ 1635}; 1636 1637DEF_JOB(StmtVisit, Stmt, StmtVisitKind) 1638DEF_JOB(MemberExprParts, MemberExpr, MemberExprPartsKind) 1639DEF_JOB(DeclRefExprParts, DeclRefExpr, DeclRefExprPartsKind) 1640DEF_JOB(OverloadExprParts, OverloadExpr, OverloadExprPartsKind) 1641DEF_JOB(ExplicitTemplateArgsVisit, ASTTemplateArgumentListInfo, 1642 ExplicitTemplateArgsVisitKind) 1643DEF_JOB(SizeOfPackExprParts, SizeOfPackExpr, SizeOfPackExprPartsKind) 1644DEF_JOB(LambdaExprParts, LambdaExpr, LambdaExprPartsKind) 1645DEF_JOB(PostChildrenVisit, void, PostChildrenVisitKind) 1646#undef DEF_JOB 1647 1648class DeclVisit : public VisitorJob { 1649public: 1650 DeclVisit(Decl *d, CXCursor parent, bool isFirst) : 1651 VisitorJob(parent, VisitorJob::DeclVisitKind, 1652 d, isFirst ? (void*) 1 : (void*) 0) {} 1653 static bool classof(const VisitorJob *VJ) { 1654 return VJ->getKind() == DeclVisitKind; 1655 } 1656 Decl *get() const { return static_cast<Decl*>(data[0]); } 1657 bool isFirst() const { return data[1] ? true : false; } 1658}; 1659class TypeLocVisit : public VisitorJob { 1660public: 1661 TypeLocVisit(TypeLoc tl, CXCursor parent) : 1662 VisitorJob(parent, VisitorJob::TypeLocVisitKind, 1663 tl.getType().getAsOpaquePtr(), tl.getOpaqueData()) {} 1664 1665 static bool classof(const VisitorJob *VJ) { 1666 return VJ->getKind() == TypeLocVisitKind; 1667 } 1668 1669 TypeLoc get() const { 1670 QualType T = QualType::getFromOpaquePtr(data[0]); 1671 return TypeLoc(T, data[1]); 1672 } 1673}; 1674 1675class LabelRefVisit : public VisitorJob { 1676public: 1677 LabelRefVisit(LabelDecl *LD, SourceLocation labelLoc, CXCursor parent) 1678 : VisitorJob(parent, VisitorJob::LabelRefVisitKind, LD, 1679 labelLoc.getPtrEncoding()) {} 1680 1681 static bool classof(const VisitorJob *VJ) { 1682 return VJ->getKind() == VisitorJob::LabelRefVisitKind; 1683 } 1684 LabelDecl *get() const { return static_cast<LabelDecl*>(data[0]); } 1685 SourceLocation getLoc() const { 1686 return SourceLocation::getFromPtrEncoding(data[1]); } 1687}; 1688 1689class NestedNameSpecifierLocVisit : public VisitorJob { 1690public: 1691 NestedNameSpecifierLocVisit(NestedNameSpecifierLoc Qualifier, CXCursor parent) 1692 : VisitorJob(parent, VisitorJob::NestedNameSpecifierLocVisitKind, 1693 Qualifier.getNestedNameSpecifier(), 1694 Qualifier.getOpaqueData()) { } 1695 1696 static bool classof(const VisitorJob *VJ) { 1697 return VJ->getKind() == VisitorJob::NestedNameSpecifierLocVisitKind; 1698 } 1699 1700 NestedNameSpecifierLoc get() const { 1701 return NestedNameSpecifierLoc(static_cast<NestedNameSpecifier*>(data[0]), 1702 data[1]); 1703 } 1704}; 1705 1706class DeclarationNameInfoVisit : public VisitorJob { 1707public: 1708 DeclarationNameInfoVisit(Stmt *S, CXCursor parent) 1709 : VisitorJob(parent, VisitorJob::DeclarationNameInfoVisitKind, S) {} 1710 static bool classof(const VisitorJob *VJ) { 1711 return VJ->getKind() == VisitorJob::DeclarationNameInfoVisitKind; 1712 } 1713 DeclarationNameInfo get() const { 1714 Stmt *S = static_cast<Stmt*>(data[0]); 1715 switch (S->getStmtClass()) { 1716 default: 1717 llvm_unreachable("Unhandled Stmt"); 1718 case clang::Stmt::MSDependentExistsStmtClass: 1719 return cast<MSDependentExistsStmt>(S)->getNameInfo(); 1720 case Stmt::CXXDependentScopeMemberExprClass: 1721 return cast<CXXDependentScopeMemberExpr>(S)->getMemberNameInfo(); 1722 case Stmt::DependentScopeDeclRefExprClass: 1723 return cast<DependentScopeDeclRefExpr>(S)->getNameInfo(); 1724 } 1725 } 1726}; 1727class MemberRefVisit : public VisitorJob { 1728public: 1729 MemberRefVisit(FieldDecl *D, SourceLocation L, CXCursor parent) 1730 : VisitorJob(parent, VisitorJob::MemberRefVisitKind, D, 1731 L.getPtrEncoding()) {} 1732 static bool classof(const VisitorJob *VJ) { 1733 return VJ->getKind() == VisitorJob::MemberRefVisitKind; 1734 } 1735 FieldDecl *get() const { 1736 return static_cast<FieldDecl*>(data[0]); 1737 } 1738 SourceLocation getLoc() const { 1739 return SourceLocation::getFromRawEncoding((unsigned)(uintptr_t) data[1]); 1740 } 1741}; 1742class EnqueueVisitor : public StmtVisitor<EnqueueVisitor, void> { 1743 VisitorWorkList &WL; 1744 CXCursor Parent; 1745public: 1746 EnqueueVisitor(VisitorWorkList &wl, CXCursor parent) 1747 : WL(wl), Parent(parent) {} 1748 1749 void VisitAddrLabelExpr(AddrLabelExpr *E); 1750 void VisitBlockExpr(BlockExpr *B); 1751 void VisitCompoundLiteralExpr(CompoundLiteralExpr *E); 1752 void VisitCompoundStmt(CompoundStmt *S); 1753 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { /* Do nothing. */ } 1754 void VisitMSDependentExistsStmt(MSDependentExistsStmt *S); 1755 void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E); 1756 void VisitCXXNewExpr(CXXNewExpr *E); 1757 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E); 1758 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E); 1759 void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E); 1760 void VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E); 1761 void VisitCXXTypeidExpr(CXXTypeidExpr *E); 1762 void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E); 1763 void VisitCXXUuidofExpr(CXXUuidofExpr *E); 1764 void VisitCXXCatchStmt(CXXCatchStmt *S); 1765 void VisitDeclRefExpr(DeclRefExpr *D); 1766 void VisitDeclStmt(DeclStmt *S); 1767 void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E); 1768 void VisitDesignatedInitExpr(DesignatedInitExpr *E); 1769 void VisitExplicitCastExpr(ExplicitCastExpr *E); 1770 void VisitForStmt(ForStmt *FS); 1771 void VisitGotoStmt(GotoStmt *GS); 1772 void VisitIfStmt(IfStmt *If); 1773 void VisitInitListExpr(InitListExpr *IE); 1774 void VisitMemberExpr(MemberExpr *M); 1775 void VisitOffsetOfExpr(OffsetOfExpr *E); 1776 void VisitObjCEncodeExpr(ObjCEncodeExpr *E); 1777 void VisitObjCMessageExpr(ObjCMessageExpr *M); 1778 void VisitOverloadExpr(OverloadExpr *E); 1779 void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E); 1780 void VisitStmt(Stmt *S); 1781 void VisitSwitchStmt(SwitchStmt *S); 1782 void VisitWhileStmt(WhileStmt *W); 1783 void VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E); 1784 void VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E); 1785 void VisitTypeTraitExpr(TypeTraitExpr *E); 1786 void VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E); 1787 void VisitExpressionTraitExpr(ExpressionTraitExpr *E); 1788 void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *U); 1789 void VisitVAArgExpr(VAArgExpr *E); 1790 void VisitSizeOfPackExpr(SizeOfPackExpr *E); 1791 void VisitPseudoObjectExpr(PseudoObjectExpr *E); 1792 void VisitOpaqueValueExpr(OpaqueValueExpr *E); 1793 void VisitLambdaExpr(LambdaExpr *E); 1794 1795private: 1796 void AddDeclarationNameInfo(Stmt *S); 1797 void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier); 1798 void AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A); 1799 void AddMemberRef(FieldDecl *D, SourceLocation L); 1800 void AddStmt(Stmt *S); 1801 void AddDecl(Decl *D, bool isFirst = true); 1802 void AddTypeLoc(TypeSourceInfo *TI); 1803 void EnqueueChildren(Stmt *S); 1804}; 1805} // end anonyous namespace 1806 1807void EnqueueVisitor::AddDeclarationNameInfo(Stmt *S) { 1808 // 'S' should always be non-null, since it comes from the 1809 // statement we are visiting. 1810 WL.push_back(DeclarationNameInfoVisit(S, Parent)); 1811} 1812 1813void 1814EnqueueVisitor::AddNestedNameSpecifierLoc(NestedNameSpecifierLoc Qualifier) { 1815 if (Qualifier) 1816 WL.push_back(NestedNameSpecifierLocVisit(Qualifier, Parent)); 1817} 1818 1819void EnqueueVisitor::AddStmt(Stmt *S) { 1820 if (S) 1821 WL.push_back(StmtVisit(S, Parent)); 1822} 1823void EnqueueVisitor::AddDecl(Decl *D, bool isFirst) { 1824 if (D) 1825 WL.push_back(DeclVisit(D, Parent, isFirst)); 1826} 1827void EnqueueVisitor:: 1828 AddExplicitTemplateArgs(const ASTTemplateArgumentListInfo *A) { 1829 if (A) 1830 WL.push_back(ExplicitTemplateArgsVisit( 1831 const_cast<ASTTemplateArgumentListInfo*>(A), Parent)); 1832} 1833void EnqueueVisitor::AddMemberRef(FieldDecl *D, SourceLocation L) { 1834 if (D) 1835 WL.push_back(MemberRefVisit(D, L, Parent)); 1836} 1837void EnqueueVisitor::AddTypeLoc(TypeSourceInfo *TI) { 1838 if (TI) 1839 WL.push_back(TypeLocVisit(TI->getTypeLoc(), Parent)); 1840 } 1841void EnqueueVisitor::EnqueueChildren(Stmt *S) { 1842 unsigned size = WL.size(); 1843 for (Stmt::child_range Child = S->children(); Child; ++Child) { 1844 AddStmt(*Child); 1845 } 1846 if (size == WL.size()) 1847 return; 1848 // Now reverse the entries we just added. This will match the DFS 1849 // ordering performed by the worklist. 1850 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 1851 std::reverse(I, E); 1852} 1853void EnqueueVisitor::VisitAddrLabelExpr(AddrLabelExpr *E) { 1854 WL.push_back(LabelRefVisit(E->getLabel(), E->getLabelLoc(), Parent)); 1855} 1856void EnqueueVisitor::VisitBlockExpr(BlockExpr *B) { 1857 AddDecl(B->getBlockDecl()); 1858} 1859void EnqueueVisitor::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 1860 EnqueueChildren(E); 1861 AddTypeLoc(E->getTypeSourceInfo()); 1862} 1863void EnqueueVisitor::VisitCompoundStmt(CompoundStmt *S) { 1864 for (CompoundStmt::reverse_body_iterator I = S->body_rbegin(), 1865 E = S->body_rend(); I != E; ++I) { 1866 AddStmt(*I); 1867 } 1868} 1869void EnqueueVisitor:: 1870VisitMSDependentExistsStmt(MSDependentExistsStmt *S) { 1871 AddStmt(S->getSubStmt()); 1872 AddDeclarationNameInfo(S); 1873 if (NestedNameSpecifierLoc QualifierLoc = S->getQualifierLoc()) 1874 AddNestedNameSpecifierLoc(QualifierLoc); 1875} 1876 1877void EnqueueVisitor:: 1878VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) { 1879 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 1880 AddDeclarationNameInfo(E); 1881 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 1882 AddNestedNameSpecifierLoc(QualifierLoc); 1883 if (!E->isImplicitAccess()) 1884 AddStmt(E->getBase()); 1885} 1886void EnqueueVisitor::VisitCXXNewExpr(CXXNewExpr *E) { 1887 // Enqueue the initializer , if any. 1888 AddStmt(E->getInitializer()); 1889 // Enqueue the array size, if any. 1890 AddStmt(E->getArraySize()); 1891 // Enqueue the allocated type. 1892 AddTypeLoc(E->getAllocatedTypeSourceInfo()); 1893 // Enqueue the placement arguments. 1894 for (unsigned I = E->getNumPlacementArgs(); I > 0; --I) 1895 AddStmt(E->getPlacementArg(I-1)); 1896} 1897void EnqueueVisitor::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *CE) { 1898 for (unsigned I = CE->getNumArgs(); I > 1 /* Yes, this is 1 */; --I) 1899 AddStmt(CE->getArg(I-1)); 1900 AddStmt(CE->getCallee()); 1901 AddStmt(CE->getArg(0)); 1902} 1903void EnqueueVisitor::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 1904 // Visit the name of the type being destroyed. 1905 AddTypeLoc(E->getDestroyedTypeInfo()); 1906 // Visit the scope type that looks disturbingly like the nested-name-specifier 1907 // but isn't. 1908 AddTypeLoc(E->getScopeTypeInfo()); 1909 // Visit the nested-name-specifier. 1910 if (NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc()) 1911 AddNestedNameSpecifierLoc(QualifierLoc); 1912 // Visit base expression. 1913 AddStmt(E->getBase()); 1914} 1915void EnqueueVisitor::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 1916 AddTypeLoc(E->getTypeSourceInfo()); 1917} 1918void EnqueueVisitor::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 1919 EnqueueChildren(E); 1920 AddTypeLoc(E->getTypeSourceInfo()); 1921} 1922void EnqueueVisitor::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 1923 EnqueueChildren(E); 1924 if (E->isTypeOperand()) 1925 AddTypeLoc(E->getTypeOperandSourceInfo()); 1926} 1927 1928void EnqueueVisitor::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr 1929 *E) { 1930 EnqueueChildren(E); 1931 AddTypeLoc(E->getTypeSourceInfo()); 1932} 1933void EnqueueVisitor::VisitCXXUuidofExpr(CXXUuidofExpr *E) { 1934 EnqueueChildren(E); 1935 if (E->isTypeOperand()) 1936 AddTypeLoc(E->getTypeOperandSourceInfo()); 1937} 1938 1939void EnqueueVisitor::VisitCXXCatchStmt(CXXCatchStmt *S) { 1940 EnqueueChildren(S); 1941 AddDecl(S->getExceptionDecl()); 1942} 1943 1944void EnqueueVisitor::VisitDeclRefExpr(DeclRefExpr *DR) { 1945 if (DR->hasExplicitTemplateArgs()) { 1946 AddExplicitTemplateArgs(&DR->getExplicitTemplateArgs()); 1947 } 1948 WL.push_back(DeclRefExprParts(DR, Parent)); 1949} 1950void EnqueueVisitor::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 1951 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 1952 AddDeclarationNameInfo(E); 1953 AddNestedNameSpecifierLoc(E->getQualifierLoc()); 1954} 1955void EnqueueVisitor::VisitDeclStmt(DeclStmt *S) { 1956 unsigned size = WL.size(); 1957 bool isFirst = true; 1958 for (DeclStmt::decl_iterator D = S->decl_begin(), DEnd = S->decl_end(); 1959 D != DEnd; ++D) { 1960 AddDecl(*D, isFirst); 1961 isFirst = false; 1962 } 1963 if (size == WL.size()) 1964 return; 1965 // Now reverse the entries we just added. This will match the DFS 1966 // ordering performed by the worklist. 1967 VisitorWorkList::iterator I = WL.begin() + size, E = WL.end(); 1968 std::reverse(I, E); 1969} 1970void EnqueueVisitor::VisitDesignatedInitExpr(DesignatedInitExpr *E) { 1971 AddStmt(E->getInit()); 1972 typedef DesignatedInitExpr::Designator Designator; 1973 for (DesignatedInitExpr::reverse_designators_iterator 1974 D = E->designators_rbegin(), DEnd = E->designators_rend(); 1975 D != DEnd; ++D) { 1976 if (D->isFieldDesignator()) { 1977 if (FieldDecl *Field = D->getField()) 1978 AddMemberRef(Field, D->getFieldLoc()); 1979 continue; 1980 } 1981 if (D->isArrayDesignator()) { 1982 AddStmt(E->getArrayIndex(*D)); 1983 continue; 1984 } 1985 assert(D->isArrayRangeDesignator() && "Unknown designator kind"); 1986 AddStmt(E->getArrayRangeEnd(*D)); 1987 AddStmt(E->getArrayRangeStart(*D)); 1988 } 1989} 1990void EnqueueVisitor::VisitExplicitCastExpr(ExplicitCastExpr *E) { 1991 EnqueueChildren(E); 1992 AddTypeLoc(E->getTypeInfoAsWritten()); 1993} 1994void EnqueueVisitor::VisitForStmt(ForStmt *FS) { 1995 AddStmt(FS->getBody()); 1996 AddStmt(FS->getInc()); 1997 AddStmt(FS->getCond()); 1998 AddDecl(FS->getConditionVariable()); 1999 AddStmt(FS->getInit()); 2000} 2001void EnqueueVisitor::VisitGotoStmt(GotoStmt *GS) { 2002 WL.push_back(LabelRefVisit(GS->getLabel(), GS->getLabelLoc(), Parent)); 2003} 2004void EnqueueVisitor::VisitIfStmt(IfStmt *If) { 2005 AddStmt(If->getElse()); 2006 AddStmt(If->getThen()); 2007 AddStmt(If->getCond()); 2008 AddDecl(If->getConditionVariable()); 2009} 2010void EnqueueVisitor::VisitInitListExpr(InitListExpr *IE) { 2011 // We care about the syntactic form of the initializer list, only. 2012 if (InitListExpr *Syntactic = IE->getSyntacticForm()) 2013 IE = Syntactic; 2014 EnqueueChildren(IE); 2015} 2016void EnqueueVisitor::VisitMemberExpr(MemberExpr *M) { 2017 WL.push_back(MemberExprParts(M, Parent)); 2018 2019 // If the base of the member access expression is an implicit 'this', don't 2020 // visit it. 2021 // FIXME: If we ever want to show these implicit accesses, this will be 2022 // unfortunate. However, clang_getCursor() relies on this behavior. 2023 if (!M->isImplicitAccess()) 2024 AddStmt(M->getBase()); 2025} 2026void EnqueueVisitor::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { 2027 AddTypeLoc(E->getEncodedTypeSourceInfo()); 2028} 2029void EnqueueVisitor::VisitObjCMessageExpr(ObjCMessageExpr *M) { 2030 EnqueueChildren(M); 2031 AddTypeLoc(M->getClassReceiverTypeInfo()); 2032} 2033void EnqueueVisitor::VisitOffsetOfExpr(OffsetOfExpr *E) { 2034 // Visit the components of the offsetof expression. 2035 for (unsigned N = E->getNumComponents(), I = N; I > 0; --I) { 2036 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode; 2037 const OffsetOfNode &Node = E->getComponent(I-1); 2038 switch (Node.getKind()) { 2039 case OffsetOfNode::Array: 2040 AddStmt(E->getIndexExpr(Node.getArrayExprIndex())); 2041 break; 2042 case OffsetOfNode::Field: 2043 AddMemberRef(Node.getField(), Node.getSourceRange().getEnd()); 2044 break; 2045 case OffsetOfNode::Identifier: 2046 case OffsetOfNode::Base: 2047 continue; 2048 } 2049 } 2050 // Visit the type into which we're computing the offset. 2051 AddTypeLoc(E->getTypeSourceInfo()); 2052} 2053void EnqueueVisitor::VisitOverloadExpr(OverloadExpr *E) { 2054 AddExplicitTemplateArgs(E->getOptionalExplicitTemplateArgs()); 2055 WL.push_back(OverloadExprParts(E, Parent)); 2056} 2057void EnqueueVisitor::VisitUnaryExprOrTypeTraitExpr( 2058 UnaryExprOrTypeTraitExpr *E) { 2059 EnqueueChildren(E); 2060 if (E->isArgumentType()) 2061 AddTypeLoc(E->getArgumentTypeInfo()); 2062} 2063void EnqueueVisitor::VisitStmt(Stmt *S) { 2064 EnqueueChildren(S); 2065} 2066void EnqueueVisitor::VisitSwitchStmt(SwitchStmt *S) { 2067 AddStmt(S->getBody()); 2068 AddStmt(S->getCond()); 2069 AddDecl(S->getConditionVariable()); 2070} 2071 2072void EnqueueVisitor::VisitWhileStmt(WhileStmt *W) { 2073 AddStmt(W->getBody()); 2074 AddStmt(W->getCond()); 2075 AddDecl(W->getConditionVariable()); 2076} 2077 2078void EnqueueVisitor::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) { 2079 AddTypeLoc(E->getQueriedTypeSourceInfo()); 2080} 2081 2082void EnqueueVisitor::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) { 2083 AddTypeLoc(E->getRhsTypeSourceInfo()); 2084 AddTypeLoc(E->getLhsTypeSourceInfo()); 2085} 2086 2087void EnqueueVisitor::VisitTypeTraitExpr(TypeTraitExpr *E) { 2088 for (unsigned I = E->getNumArgs(); I > 0; --I) 2089 AddTypeLoc(E->getArg(I-1)); 2090} 2091 2092void EnqueueVisitor::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 2093 AddTypeLoc(E->getQueriedTypeSourceInfo()); 2094} 2095 2096void EnqueueVisitor::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 2097 EnqueueChildren(E); 2098} 2099 2100void EnqueueVisitor::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *U) { 2101 VisitOverloadExpr(U); 2102 if (!U->isImplicitAccess()) 2103 AddStmt(U->getBase()); 2104} 2105void EnqueueVisitor::VisitVAArgExpr(VAArgExpr *E) { 2106 AddStmt(E->getSubExpr()); 2107 AddTypeLoc(E->getWrittenTypeInfo()); 2108} 2109void EnqueueVisitor::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 2110 WL.push_back(SizeOfPackExprParts(E, Parent)); 2111} 2112void EnqueueVisitor::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 2113 // If the opaque value has a source expression, just transparently 2114 // visit that. This is useful for (e.g.) pseudo-object expressions. 2115 if (Expr *SourceExpr = E->getSourceExpr()) 2116 return Visit(SourceExpr); 2117} 2118void EnqueueVisitor::VisitLambdaExpr(LambdaExpr *E) { 2119 AddStmt(E->getBody()); 2120 WL.push_back(LambdaExprParts(E, Parent)); 2121} 2122void EnqueueVisitor::VisitPseudoObjectExpr(PseudoObjectExpr *E) { 2123 // Treat the expression like its syntactic form. 2124 Visit(E->getSyntacticForm()); 2125} 2126 2127void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, Stmt *S) { 2128 EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S); 2129} 2130 2131bool CursorVisitor::IsInRegionOfInterest(CXCursor C) { 2132 if (RegionOfInterest.isValid()) { 2133 SourceRange Range = getRawCursorExtent(C); 2134 if (Range.isInvalid() || CompareRegionOfInterest(Range)) 2135 return false; 2136 } 2137 return true; 2138} 2139 2140bool CursorVisitor::RunVisitorWorkList(VisitorWorkList &WL) { 2141 while (!WL.empty()) { 2142 // Dequeue the worklist item. 2143 VisitorJob LI = WL.back(); 2144 WL.pop_back(); 2145 2146 // Set the Parent field, then back to its old value once we're done. 2147 SetParentRAII SetParent(Parent, StmtParent, LI.getParent()); 2148 2149 switch (LI.getKind()) { 2150 case VisitorJob::DeclVisitKind: { 2151 Decl *D = cast<DeclVisit>(&LI)->get(); 2152 if (!D) 2153 continue; 2154 2155 // For now, perform default visitation for Decls. 2156 if (Visit(MakeCXCursor(D, TU, RegionOfInterest, 2157 cast<DeclVisit>(&LI)->isFirst()))) 2158 return true; 2159 2160 continue; 2161 } 2162 case VisitorJob::ExplicitTemplateArgsVisitKind: { 2163 const ASTTemplateArgumentListInfo *ArgList = 2164 cast<ExplicitTemplateArgsVisit>(&LI)->get(); 2165 for (const TemplateArgumentLoc *Arg = ArgList->getTemplateArgs(), 2166 *ArgEnd = Arg + ArgList->NumTemplateArgs; 2167 Arg != ArgEnd; ++Arg) { 2168 if (VisitTemplateArgumentLoc(*Arg)) 2169 return true; 2170 } 2171 continue; 2172 } 2173 case VisitorJob::TypeLocVisitKind: { 2174 // Perform default visitation for TypeLocs. 2175 if (Visit(cast<TypeLocVisit>(&LI)->get())) 2176 return true; 2177 continue; 2178 } 2179 case VisitorJob::LabelRefVisitKind: { 2180 LabelDecl *LS = cast<LabelRefVisit>(&LI)->get(); 2181 if (LabelStmt *stmt = LS->getStmt()) { 2182 if (Visit(MakeCursorLabelRef(stmt, cast<LabelRefVisit>(&LI)->getLoc(), 2183 TU))) { 2184 return true; 2185 } 2186 } 2187 continue; 2188 } 2189 2190 case VisitorJob::NestedNameSpecifierLocVisitKind: { 2191 NestedNameSpecifierLocVisit *V = cast<NestedNameSpecifierLocVisit>(&LI); 2192 if (VisitNestedNameSpecifierLoc(V->get())) 2193 return true; 2194 continue; 2195 } 2196 2197 case VisitorJob::DeclarationNameInfoVisitKind: { 2198 if (VisitDeclarationNameInfo(cast<DeclarationNameInfoVisit>(&LI) 2199 ->get())) 2200 return true; 2201 continue; 2202 } 2203 case VisitorJob::MemberRefVisitKind: { 2204 MemberRefVisit *V = cast<MemberRefVisit>(&LI); 2205 if (Visit(MakeCursorMemberRef(V->get(), V->getLoc(), TU))) 2206 return true; 2207 continue; 2208 } 2209 case VisitorJob::StmtVisitKind: { 2210 Stmt *S = cast<StmtVisit>(&LI)->get(); 2211 if (!S) 2212 continue; 2213 2214 // Update the current cursor. 2215 CXCursor Cursor = MakeCXCursor(S, StmtParent, TU, RegionOfInterest); 2216 if (!IsInRegionOfInterest(Cursor)) 2217 continue; 2218 switch (Visitor(Cursor, Parent, ClientData)) { 2219 case CXChildVisit_Break: return true; 2220 case CXChildVisit_Continue: break; 2221 case CXChildVisit_Recurse: 2222 if (PostChildrenVisitor) 2223 WL.push_back(PostChildrenVisit(0, Cursor)); 2224 EnqueueWorkList(WL, S); 2225 break; 2226 } 2227 continue; 2228 } 2229 case VisitorJob::MemberExprPartsKind: { 2230 // Handle the other pieces in the MemberExpr besides the base. 2231 MemberExpr *M = cast<MemberExprParts>(&LI)->get(); 2232 2233 // Visit the nested-name-specifier 2234 if (NestedNameSpecifierLoc QualifierLoc = M->getQualifierLoc()) 2235 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2236 return true; 2237 2238 // Visit the declaration name. 2239 if (VisitDeclarationNameInfo(M->getMemberNameInfo())) 2240 return true; 2241 2242 // Visit the explicitly-specified template arguments, if any. 2243 if (M->hasExplicitTemplateArgs()) { 2244 for (const TemplateArgumentLoc *Arg = M->getTemplateArgs(), 2245 *ArgEnd = Arg + M->getNumTemplateArgs(); 2246 Arg != ArgEnd; ++Arg) { 2247 if (VisitTemplateArgumentLoc(*Arg)) 2248 return true; 2249 } 2250 } 2251 continue; 2252 } 2253 case VisitorJob::DeclRefExprPartsKind: { 2254 DeclRefExpr *DR = cast<DeclRefExprParts>(&LI)->get(); 2255 // Visit nested-name-specifier, if present. 2256 if (NestedNameSpecifierLoc QualifierLoc = DR->getQualifierLoc()) 2257 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2258 return true; 2259 // Visit declaration name. 2260 if (VisitDeclarationNameInfo(DR->getNameInfo())) 2261 return true; 2262 continue; 2263 } 2264 case VisitorJob::OverloadExprPartsKind: { 2265 OverloadExpr *O = cast<OverloadExprParts>(&LI)->get(); 2266 // Visit the nested-name-specifier. 2267 if (NestedNameSpecifierLoc QualifierLoc = O->getQualifierLoc()) 2268 if (VisitNestedNameSpecifierLoc(QualifierLoc)) 2269 return true; 2270 // Visit the declaration name. 2271 if (VisitDeclarationNameInfo(O->getNameInfo())) 2272 return true; 2273 // Visit the overloaded declaration reference. 2274 if (Visit(MakeCursorOverloadedDeclRef(O, TU))) 2275 return true; 2276 continue; 2277 } 2278 case VisitorJob::SizeOfPackExprPartsKind: { 2279 SizeOfPackExpr *E = cast<SizeOfPackExprParts>(&LI)->get(); 2280 NamedDecl *Pack = E->getPack(); 2281 if (isa<TemplateTypeParmDecl>(Pack)) { 2282 if (Visit(MakeCursorTypeRef(cast<TemplateTypeParmDecl>(Pack), 2283 E->getPackLoc(), TU))) 2284 return true; 2285 2286 continue; 2287 } 2288 2289 if (isa<TemplateTemplateParmDecl>(Pack)) { 2290 if (Visit(MakeCursorTemplateRef(cast<TemplateTemplateParmDecl>(Pack), 2291 E->getPackLoc(), TU))) 2292 return true; 2293 2294 continue; 2295 } 2296 2297 // Non-type template parameter packs and function parameter packs are 2298 // treated like DeclRefExpr cursors. 2299 continue; 2300 } 2301 2302 case VisitorJob::LambdaExprPartsKind: { 2303 // Visit captures. 2304 LambdaExpr *E = cast<LambdaExprParts>(&LI)->get(); 2305 for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(), 2306 CEnd = E->explicit_capture_end(); 2307 C != CEnd; ++C) { 2308 if (C->capturesThis()) 2309 continue; 2310 2311 if (Visit(MakeCursorVariableRef(C->getCapturedVar(), 2312 C->getLocation(), 2313 TU))) 2314 return true; 2315 } 2316 2317 // Visit parameters and return type, if present. 2318 if (E->hasExplicitParameters() || E->hasExplicitResultType()) { 2319 TypeLoc TL = E->getCallOperator()->getTypeSourceInfo()->getTypeLoc(); 2320 if (E->hasExplicitParameters() && E->hasExplicitResultType()) { 2321 // Visit the whole type. 2322 if (Visit(TL)) 2323 return true; 2324 } else if (isa<FunctionProtoTypeLoc>(TL)) { 2325 FunctionProtoTypeLoc Proto = cast<FunctionProtoTypeLoc>(TL); 2326 if (E->hasExplicitParameters()) { 2327 // Visit parameters. 2328 for (unsigned I = 0, N = Proto.getNumArgs(); I != N; ++I) 2329 if (Visit(MakeCXCursor(Proto.getArg(I), TU))) 2330 return true; 2331 } else { 2332 // Visit result type. 2333 if (Visit(Proto.getResultLoc())) 2334 return true; 2335 } 2336 } 2337 } 2338 break; 2339 } 2340 2341 case VisitorJob::PostChildrenVisitKind: 2342 if (PostChildrenVisitor(Parent, ClientData)) 2343 return true; 2344 break; 2345 } 2346 } 2347 return false; 2348} 2349 2350bool CursorVisitor::Visit(Stmt *S) { 2351 VisitorWorkList *WL = 0; 2352 if (!WorkListFreeList.empty()) { 2353 WL = WorkListFreeList.back(); 2354 WL->clear(); 2355 WorkListFreeList.pop_back(); 2356 } 2357 else { 2358 WL = new VisitorWorkList(); 2359 WorkListCache.push_back(WL); 2360 } 2361 EnqueueWorkList(*WL, S); 2362 bool result = RunVisitorWorkList(*WL); 2363 WorkListFreeList.push_back(WL); 2364 return result; 2365} 2366 2367namespace { 2368typedef llvm::SmallVector<SourceRange, 4> RefNamePieces; 2369RefNamePieces buildPieces(unsigned NameFlags, bool IsMemberRefExpr, 2370 const DeclarationNameInfo &NI, 2371 const SourceRange &QLoc, 2372 const ASTTemplateArgumentListInfo *TemplateArgs = 0){ 2373 const bool WantQualifier = NameFlags & CXNameRange_WantQualifier; 2374 const bool WantTemplateArgs = NameFlags & CXNameRange_WantTemplateArgs; 2375 const bool WantSinglePiece = NameFlags & CXNameRange_WantSinglePiece; 2376 2377 const DeclarationName::NameKind Kind = NI.getName().getNameKind(); 2378 2379 RefNamePieces Pieces; 2380 2381 if (WantQualifier && QLoc.isValid()) 2382 Pieces.push_back(QLoc); 2383 2384 if (Kind != DeclarationName::CXXOperatorName || IsMemberRefExpr) 2385 Pieces.push_back(NI.getLoc()); 2386 2387 if (WantTemplateArgs && TemplateArgs) 2388 Pieces.push_back(SourceRange(TemplateArgs->LAngleLoc, 2389 TemplateArgs->RAngleLoc)); 2390 2391 if (Kind == DeclarationName::CXXOperatorName) { 2392 Pieces.push_back(SourceLocation::getFromRawEncoding( 2393 NI.getInfo().CXXOperatorName.BeginOpNameLoc)); 2394 Pieces.push_back(SourceLocation::getFromRawEncoding( 2395 NI.getInfo().CXXOperatorName.EndOpNameLoc)); 2396 } 2397 2398 if (WantSinglePiece) { 2399 SourceRange R(Pieces.front().getBegin(), Pieces.back().getEnd()); 2400 Pieces.clear(); 2401 Pieces.push_back(R); 2402 } 2403 2404 return Pieces; 2405} 2406} 2407 2408//===----------------------------------------------------------------------===// 2409// Misc. API hooks. 2410//===----------------------------------------------------------------------===// 2411 2412static llvm::sys::Mutex EnableMultithreadingMutex; 2413static bool EnabledMultithreading; 2414 2415static void fatal_error_handler(void *user_data, const std::string& reason) { 2416 // Write the result out to stderr avoiding errs() because raw_ostreams can 2417 // call report_fatal_error. 2418 fprintf(stderr, "LIBCLANG FATAL ERROR: %s\n", reason.c_str()); 2419 ::abort(); 2420} 2421 2422extern "C" { 2423CXIndex clang_createIndex(int excludeDeclarationsFromPCH, 2424 int displayDiagnostics) { 2425 // Disable pretty stack trace functionality, which will otherwise be a very 2426 // poor citizen of the world and set up all sorts of signal handlers. 2427 llvm::DisablePrettyStackTrace = true; 2428 2429 // We use crash recovery to make some of our APIs more reliable, implicitly 2430 // enable it. 2431 llvm::CrashRecoveryContext::Enable(); 2432 2433 // Enable support for multithreading in LLVM. 2434 { 2435 llvm::sys::ScopedLock L(EnableMultithreadingMutex); 2436 if (!EnabledMultithreading) { 2437 llvm::install_fatal_error_handler(fatal_error_handler, 0); 2438 llvm::llvm_start_multithreaded(); 2439 EnabledMultithreading = true; 2440 } 2441 } 2442 2443 CIndexer *CIdxr = new CIndexer(); 2444 if (excludeDeclarationsFromPCH) 2445 CIdxr->setOnlyLocalDecls(); 2446 if (displayDiagnostics) 2447 CIdxr->setDisplayDiagnostics(); 2448 2449 if (getenv("LIBCLANG_BGPRIO_INDEX")) 2450 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() | 2451 CXGlobalOpt_ThreadBackgroundPriorityForIndexing); 2452 if (getenv("LIBCLANG_BGPRIO_EDIT")) 2453 CIdxr->setCXGlobalOptFlags(CIdxr->getCXGlobalOptFlags() | 2454 CXGlobalOpt_ThreadBackgroundPriorityForEditing); 2455 2456 return CIdxr; 2457} 2458 2459void clang_disposeIndex(CXIndex CIdx) { 2460 if (CIdx) 2461 delete static_cast<CIndexer *>(CIdx); 2462} 2463 2464void clang_CXIndex_setGlobalOptions(CXIndex CIdx, unsigned options) { 2465 if (CIdx) 2466 static_cast<CIndexer *>(CIdx)->setCXGlobalOptFlags(options); 2467} 2468 2469unsigned clang_CXIndex_getGlobalOptions(CXIndex CIdx) { 2470 if (CIdx) 2471 return static_cast<CIndexer *>(CIdx)->getCXGlobalOptFlags(); 2472 return 0; 2473} 2474 2475void clang_toggleCrashRecovery(unsigned isEnabled) { 2476 if (isEnabled) 2477 llvm::CrashRecoveryContext::Enable(); 2478 else 2479 llvm::CrashRecoveryContext::Disable(); 2480} 2481 2482CXTranslationUnit clang_createTranslationUnit(CXIndex CIdx, 2483 const char *ast_filename) { 2484 if (!CIdx) 2485 return 0; 2486 2487 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 2488 FileSystemOptions FileSystemOpts; 2489 FileSystemOpts.WorkingDir = CXXIdx->getWorkingDirectory(); 2490 2491 IntrusiveRefCntPtr<DiagnosticsEngine> Diags; 2492 ASTUnit *TU = ASTUnit::LoadFromASTFile(ast_filename, Diags, FileSystemOpts, 2493 CXXIdx->getOnlyLocalDecls(), 2494 0, 0, 2495 /*CaptureDiagnostics=*/true, 2496 /*AllowPCHWithCompilerErrors=*/true, 2497 /*UserFilesAreVolatile=*/true); 2498 return MakeCXTranslationUnit(CXXIdx, TU); 2499} 2500 2501unsigned clang_defaultEditingTranslationUnitOptions() { 2502 return CXTranslationUnit_PrecompiledPreamble | 2503 CXTranslationUnit_CacheCompletionResults; 2504} 2505 2506CXTranslationUnit 2507clang_createTranslationUnitFromSourceFile(CXIndex CIdx, 2508 const char *source_filename, 2509 int num_command_line_args, 2510 const char * const *command_line_args, 2511 unsigned num_unsaved_files, 2512 struct CXUnsavedFile *unsaved_files) { 2513 unsigned Options = CXTranslationUnit_DetailedPreprocessingRecord; 2514 return clang_parseTranslationUnit(CIdx, source_filename, 2515 command_line_args, num_command_line_args, 2516 unsaved_files, num_unsaved_files, 2517 Options); 2518} 2519 2520struct ParseTranslationUnitInfo { 2521 CXIndex CIdx; 2522 const char *source_filename; 2523 const char *const *command_line_args; 2524 int num_command_line_args; 2525 struct CXUnsavedFile *unsaved_files; 2526 unsigned num_unsaved_files; 2527 unsigned options; 2528 CXTranslationUnit result; 2529}; 2530static void clang_parseTranslationUnit_Impl(void *UserData) { 2531 ParseTranslationUnitInfo *PTUI = 2532 static_cast<ParseTranslationUnitInfo*>(UserData); 2533 CXIndex CIdx = PTUI->CIdx; 2534 const char *source_filename = PTUI->source_filename; 2535 const char * const *command_line_args = PTUI->command_line_args; 2536 int num_command_line_args = PTUI->num_command_line_args; 2537 struct CXUnsavedFile *unsaved_files = PTUI->unsaved_files; 2538 unsigned num_unsaved_files = PTUI->num_unsaved_files; 2539 unsigned options = PTUI->options; 2540 PTUI->result = 0; 2541 2542 if (!CIdx) 2543 return; 2544 2545 CIndexer *CXXIdx = static_cast<CIndexer *>(CIdx); 2546 2547 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing)) 2548 setThreadBackgroundPriority(); 2549 2550 bool PrecompilePreamble = options & CXTranslationUnit_PrecompiledPreamble; 2551 // FIXME: Add a flag for modules. 2552 TranslationUnitKind TUKind 2553 = (options & CXTranslationUnit_Incomplete)? TU_Prefix : TU_Complete; 2554 bool CacheCodeCompetionResults 2555 = options & CXTranslationUnit_CacheCompletionResults; 2556 bool IncludeBriefCommentsInCodeCompletion 2557 = options & CXTranslationUnit_IncludeBriefCommentsInCodeCompletion; 2558 bool SkipFunctionBodies = options & CXTranslationUnit_SkipFunctionBodies; 2559 2560 // Configure the diagnostics. 2561 DiagnosticOptions DiagOpts; 2562 IntrusiveRefCntPtr<DiagnosticsEngine> 2563 Diags(CompilerInstance::createDiagnostics(DiagOpts, num_command_line_args, 2564 command_line_args)); 2565 2566 // Recover resources if we crash before exiting this function. 2567 llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine, 2568 llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> > 2569 DiagCleanup(Diags.getPtr()); 2570 2571 OwningPtr<std::vector<ASTUnit::RemappedFile> > 2572 RemappedFiles(new std::vector<ASTUnit::RemappedFile>()); 2573 2574 // Recover resources if we crash before exiting this function. 2575 llvm::CrashRecoveryContextCleanupRegistrar< 2576 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get()); 2577 2578 for (unsigned I = 0; I != num_unsaved_files; ++I) { 2579 StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length); 2580 const llvm::MemoryBuffer *Buffer 2581 = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename); 2582 RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename, 2583 Buffer)); 2584 } 2585 2586 OwningPtr<std::vector<const char *> > 2587 Args(new std::vector<const char*>()); 2588 2589 // Recover resources if we crash before exiting this method. 2590 llvm::CrashRecoveryContextCleanupRegistrar<std::vector<const char*> > 2591 ArgsCleanup(Args.get()); 2592 2593 // Since the Clang C library is primarily used by batch tools dealing with 2594 // (often very broken) source code, where spell-checking can have a 2595 // significant negative impact on performance (particularly when 2596 // precompiled headers are involved), we disable it by default. 2597 // Only do this if we haven't found a spell-checking-related argument. 2598 bool FoundSpellCheckingArgument = false; 2599 for (int I = 0; I != num_command_line_args; ++I) { 2600 if (strcmp(command_line_args[I], "-fno-spell-checking") == 0 || 2601 strcmp(command_line_args[I], "-fspell-checking") == 0) { 2602 FoundSpellCheckingArgument = true; 2603 break; 2604 } 2605 } 2606 if (!FoundSpellCheckingArgument) 2607 Args->push_back("-fno-spell-checking"); 2608 2609 Args->insert(Args->end(), command_line_args, 2610 command_line_args + num_command_line_args); 2611 2612 // The 'source_filename' argument is optional. If the caller does not 2613 // specify it then it is assumed that the source file is specified 2614 // in the actual argument list. 2615 // Put the source file after command_line_args otherwise if '-x' flag is 2616 // present it will be unused. 2617 if (source_filename) 2618 Args->push_back(source_filename); 2619 2620 // Do we need the detailed preprocessing record? 2621 if (options & CXTranslationUnit_DetailedPreprocessingRecord) { 2622 Args->push_back("-Xclang"); 2623 Args->push_back("-detailed-preprocessing-record"); 2624 } 2625 2626 unsigned NumErrors = Diags->getClient()->getNumErrors(); 2627 OwningPtr<ASTUnit> ErrUnit; 2628 OwningPtr<ASTUnit> Unit( 2629 ASTUnit::LoadFromCommandLine(Args->size() ? &(*Args)[0] : 0 2630 /* vector::data() not portable */, 2631 Args->size() ? (&(*Args)[0] + Args->size()) :0, 2632 Diags, 2633 CXXIdx->getClangResourcesPath(), 2634 CXXIdx->getOnlyLocalDecls(), 2635 /*CaptureDiagnostics=*/true, 2636 RemappedFiles->size() ? &(*RemappedFiles)[0]:0, 2637 RemappedFiles->size(), 2638 /*RemappedFilesKeepOriginalName=*/true, 2639 PrecompilePreamble, 2640 TUKind, 2641 CacheCodeCompetionResults, 2642 IncludeBriefCommentsInCodeCompletion, 2643 /*AllowPCHWithCompilerErrors=*/true, 2644 SkipFunctionBodies, 2645 /*UserFilesAreVolatile=*/true, 2646 &ErrUnit)); 2647 2648 if (NumErrors != Diags->getClient()->getNumErrors()) { 2649 // Make sure to check that 'Unit' is non-NULL. 2650 if (CXXIdx->getDisplayDiagnostics()) 2651 printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get()); 2652 } 2653 2654 PTUI->result = MakeCXTranslationUnit(CXXIdx, Unit.take()); 2655} 2656CXTranslationUnit clang_parseTranslationUnit(CXIndex CIdx, 2657 const char *source_filename, 2658 const char * const *command_line_args, 2659 int num_command_line_args, 2660 struct CXUnsavedFile *unsaved_files, 2661 unsigned num_unsaved_files, 2662 unsigned options) { 2663 ParseTranslationUnitInfo PTUI = { CIdx, source_filename, command_line_args, 2664 num_command_line_args, unsaved_files, 2665 num_unsaved_files, options, 0 }; 2666 llvm::CrashRecoveryContext CRC; 2667 2668 if (!RunSafely(CRC, clang_parseTranslationUnit_Impl, &PTUI)) { 2669 fprintf(stderr, "libclang: crash detected during parsing: {\n"); 2670 fprintf(stderr, " 'source_filename' : '%s'\n", source_filename); 2671 fprintf(stderr, " 'command_line_args' : ["); 2672 for (int i = 0; i != num_command_line_args; ++i) { 2673 if (i) 2674 fprintf(stderr, ", "); 2675 fprintf(stderr, "'%s'", command_line_args[i]); 2676 } 2677 fprintf(stderr, "],\n"); 2678 fprintf(stderr, " 'unsaved_files' : ["); 2679 for (unsigned i = 0; i != num_unsaved_files; ++i) { 2680 if (i) 2681 fprintf(stderr, ", "); 2682 fprintf(stderr, "('%s', '...', %ld)", unsaved_files[i].Filename, 2683 unsaved_files[i].Length); 2684 } 2685 fprintf(stderr, "],\n"); 2686 fprintf(stderr, " 'options' : %d,\n", options); 2687 fprintf(stderr, "}\n"); 2688 2689 return 0; 2690 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) { 2691 PrintLibclangResourceUsage(PTUI.result); 2692 } 2693 2694 return PTUI.result; 2695} 2696 2697unsigned clang_defaultSaveOptions(CXTranslationUnit TU) { 2698 return CXSaveTranslationUnit_None; 2699} 2700 2701namespace { 2702 2703struct SaveTranslationUnitInfo { 2704 CXTranslationUnit TU; 2705 const char *FileName; 2706 unsigned options; 2707 CXSaveError result; 2708}; 2709 2710} 2711 2712static void clang_saveTranslationUnit_Impl(void *UserData) { 2713 SaveTranslationUnitInfo *STUI = 2714 static_cast<SaveTranslationUnitInfo*>(UserData); 2715 2716 CIndexer *CXXIdx = (CIndexer*)STUI->TU->CIdx; 2717 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForIndexing)) 2718 setThreadBackgroundPriority(); 2719 2720 STUI->result = static_cast<ASTUnit *>(STUI->TU->TUData)->Save(STUI->FileName); 2721} 2722 2723int clang_saveTranslationUnit(CXTranslationUnit TU, const char *FileName, 2724 unsigned options) { 2725 if (!TU) 2726 return CXSaveError_InvalidTU; 2727 2728 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 2729 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 2730 if (!CXXUnit->hasSema()) 2731 return CXSaveError_InvalidTU; 2732 2733 SaveTranslationUnitInfo STUI = { TU, FileName, options, CXSaveError_None }; 2734 2735 if (!CXXUnit->getDiagnostics().hasUnrecoverableErrorOccurred() || 2736 getenv("LIBCLANG_NOTHREADS")) { 2737 clang_saveTranslationUnit_Impl(&STUI); 2738 2739 if (getenv("LIBCLANG_RESOURCE_USAGE")) 2740 PrintLibclangResourceUsage(TU); 2741 2742 return STUI.result; 2743 } 2744 2745 // We have an AST that has invalid nodes due to compiler errors. 2746 // Use a crash recovery thread for protection. 2747 2748 llvm::CrashRecoveryContext CRC; 2749 2750 if (!RunSafely(CRC, clang_saveTranslationUnit_Impl, &STUI)) { 2751 fprintf(stderr, "libclang: crash detected during AST saving: {\n"); 2752 fprintf(stderr, " 'filename' : '%s'\n", FileName); 2753 fprintf(stderr, " 'options' : %d,\n", options); 2754 fprintf(stderr, "}\n"); 2755 2756 return CXSaveError_Unknown; 2757 2758 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) { 2759 PrintLibclangResourceUsage(TU); 2760 } 2761 2762 return STUI.result; 2763} 2764 2765void clang_disposeTranslationUnit(CXTranslationUnit CTUnit) { 2766 if (CTUnit) { 2767 // If the translation unit has been marked as unsafe to free, just discard 2768 // it. 2769 if (static_cast<ASTUnit *>(CTUnit->TUData)->isUnsafeToFree()) 2770 return; 2771 2772 delete static_cast<ASTUnit *>(CTUnit->TUData); 2773 disposeCXStringPool(CTUnit->StringPool); 2774 delete static_cast<CXDiagnosticSetImpl *>(CTUnit->Diagnostics); 2775 disposeOverridenCXCursorsPool(CTUnit->OverridenCursorsPool); 2776 delete CTUnit; 2777 } 2778} 2779 2780unsigned clang_defaultReparseOptions(CXTranslationUnit TU) { 2781 return CXReparse_None; 2782} 2783 2784struct ReparseTranslationUnitInfo { 2785 CXTranslationUnit TU; 2786 unsigned num_unsaved_files; 2787 struct CXUnsavedFile *unsaved_files; 2788 unsigned options; 2789 int result; 2790}; 2791 2792static void clang_reparseTranslationUnit_Impl(void *UserData) { 2793 ReparseTranslationUnitInfo *RTUI = 2794 static_cast<ReparseTranslationUnitInfo*>(UserData); 2795 CXTranslationUnit TU = RTUI->TU; 2796 2797 // Reset the associated diagnostics. 2798 delete static_cast<CXDiagnosticSetImpl*>(TU->Diagnostics); 2799 TU->Diagnostics = 0; 2800 2801 unsigned num_unsaved_files = RTUI->num_unsaved_files; 2802 struct CXUnsavedFile *unsaved_files = RTUI->unsaved_files; 2803 unsigned options = RTUI->options; 2804 (void) options; 2805 RTUI->result = 1; 2806 2807 if (!TU) 2808 return; 2809 2810 CIndexer *CXXIdx = (CIndexer*)TU->CIdx; 2811 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 2812 setThreadBackgroundPriority(); 2813 2814 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 2815 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 2816 2817 OwningPtr<std::vector<ASTUnit::RemappedFile> > 2818 RemappedFiles(new std::vector<ASTUnit::RemappedFile>()); 2819 2820 // Recover resources if we crash before exiting this function. 2821 llvm::CrashRecoveryContextCleanupRegistrar< 2822 std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get()); 2823 2824 for (unsigned I = 0; I != num_unsaved_files; ++I) { 2825 StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length); 2826 const llvm::MemoryBuffer *Buffer 2827 = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename); 2828 RemappedFiles->push_back(std::make_pair(unsaved_files[I].Filename, 2829 Buffer)); 2830 } 2831 2832 if (!CXXUnit->Reparse(RemappedFiles->size() ? &(*RemappedFiles)[0] : 0, 2833 RemappedFiles->size())) 2834 RTUI->result = 0; 2835} 2836 2837int clang_reparseTranslationUnit(CXTranslationUnit TU, 2838 unsigned num_unsaved_files, 2839 struct CXUnsavedFile *unsaved_files, 2840 unsigned options) { 2841 ReparseTranslationUnitInfo RTUI = { TU, num_unsaved_files, unsaved_files, 2842 options, 0 }; 2843 2844 if (getenv("LIBCLANG_NOTHREADS")) { 2845 clang_reparseTranslationUnit_Impl(&RTUI); 2846 return RTUI.result; 2847 } 2848 2849 llvm::CrashRecoveryContext CRC; 2850 2851 if (!RunSafely(CRC, clang_reparseTranslationUnit_Impl, &RTUI)) { 2852 fprintf(stderr, "libclang: crash detected during reparsing\n"); 2853 static_cast<ASTUnit *>(TU->TUData)->setUnsafeToFree(true); 2854 return 1; 2855 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) 2856 PrintLibclangResourceUsage(TU); 2857 2858 return RTUI.result; 2859} 2860 2861 2862CXString clang_getTranslationUnitSpelling(CXTranslationUnit CTUnit) { 2863 if (!CTUnit) 2864 return createCXString(""); 2865 2866 ASTUnit *CXXUnit = static_cast<ASTUnit *>(CTUnit->TUData); 2867 return createCXString(CXXUnit->getOriginalSourceFileName(), true); 2868} 2869 2870CXCursor clang_getTranslationUnitCursor(CXTranslationUnit TU) { 2871 ASTUnit *CXXUnit = static_cast<ASTUnit*>(TU->TUData); 2872 return MakeCXCursor(CXXUnit->getASTContext().getTranslationUnitDecl(), TU); 2873} 2874 2875} // end: extern "C" 2876 2877//===----------------------------------------------------------------------===// 2878// CXFile Operations. 2879//===----------------------------------------------------------------------===// 2880 2881extern "C" { 2882CXString clang_getFileName(CXFile SFile) { 2883 if (!SFile) 2884 return createCXString((const char*)NULL); 2885 2886 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 2887 return createCXString(FEnt->getName()); 2888} 2889 2890time_t clang_getFileTime(CXFile SFile) { 2891 if (!SFile) 2892 return 0; 2893 2894 FileEntry *FEnt = static_cast<FileEntry *>(SFile); 2895 return FEnt->getModificationTime(); 2896} 2897 2898CXFile clang_getFile(CXTranslationUnit tu, const char *file_name) { 2899 if (!tu) 2900 return 0; 2901 2902 ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData); 2903 2904 FileManager &FMgr = CXXUnit->getFileManager(); 2905 return const_cast<FileEntry *>(FMgr.getFile(file_name)); 2906} 2907 2908unsigned clang_isFileMultipleIncludeGuarded(CXTranslationUnit tu, CXFile file) { 2909 if (!tu || !file) 2910 return 0; 2911 2912 ASTUnit *CXXUnit = static_cast<ASTUnit *>(tu->TUData); 2913 FileEntry *FEnt = static_cast<FileEntry *>(file); 2914 return CXXUnit->getPreprocessor().getHeaderSearchInfo() 2915 .isFileMultipleIncludeGuarded(FEnt); 2916} 2917 2918} // end: extern "C" 2919 2920//===----------------------------------------------------------------------===// 2921// CXCursor Operations. 2922//===----------------------------------------------------------------------===// 2923 2924static Decl *getDeclFromExpr(Stmt *E) { 2925 if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 2926 return getDeclFromExpr(CE->getSubExpr()); 2927 2928 if (DeclRefExpr *RefExpr = dyn_cast<DeclRefExpr>(E)) 2929 return RefExpr->getDecl(); 2930 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) 2931 return ME->getMemberDecl(); 2932 if (ObjCIvarRefExpr *RE = dyn_cast<ObjCIvarRefExpr>(E)) 2933 return RE->getDecl(); 2934 if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(E)) { 2935 if (PRE->isExplicitProperty()) 2936 return PRE->getExplicitProperty(); 2937 // It could be messaging both getter and setter as in: 2938 // ++myobj.myprop; 2939 // in which case prefer to associate the setter since it is less obvious 2940 // from inspecting the source that the setter is going to get called. 2941 if (PRE->isMessagingSetter()) 2942 return PRE->getImplicitPropertySetter(); 2943 return PRE->getImplicitPropertyGetter(); 2944 } 2945 if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) 2946 return getDeclFromExpr(POE->getSyntacticForm()); 2947 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) 2948 if (Expr *Src = OVE->getSourceExpr()) 2949 return getDeclFromExpr(Src); 2950 2951 if (CallExpr *CE = dyn_cast<CallExpr>(E)) 2952 return getDeclFromExpr(CE->getCallee()); 2953 if (CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E)) 2954 if (!CE->isElidable()) 2955 return CE->getConstructor(); 2956 if (ObjCMessageExpr *OME = dyn_cast<ObjCMessageExpr>(E)) 2957 return OME->getMethodDecl(); 2958 2959 if (ObjCProtocolExpr *PE = dyn_cast<ObjCProtocolExpr>(E)) 2960 return PE->getProtocol(); 2961 if (SubstNonTypeTemplateParmPackExpr *NTTP 2962 = dyn_cast<SubstNonTypeTemplateParmPackExpr>(E)) 2963 return NTTP->getParameterPack(); 2964 if (SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 2965 if (isa<NonTypeTemplateParmDecl>(SizeOfPack->getPack()) || 2966 isa<ParmVarDecl>(SizeOfPack->getPack())) 2967 return SizeOfPack->getPack(); 2968 2969 return 0; 2970} 2971 2972static SourceLocation getLocationFromExpr(Expr *E) { 2973 if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 2974 return getLocationFromExpr(CE->getSubExpr()); 2975 2976 if (ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E)) 2977 return /*FIXME:*/Msg->getLeftLoc(); 2978 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 2979 return DRE->getLocation(); 2980 if (MemberExpr *Member = dyn_cast<MemberExpr>(E)) 2981 return Member->getMemberLoc(); 2982 if (ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E)) 2983 return Ivar->getLocation(); 2984 if (SizeOfPackExpr *SizeOfPack = dyn_cast<SizeOfPackExpr>(E)) 2985 return SizeOfPack->getPackLoc(); 2986 if (ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E)) 2987 return PropRef->getLocation(); 2988 2989 return E->getLocStart(); 2990} 2991 2992extern "C" { 2993 2994unsigned clang_visitChildren(CXCursor parent, 2995 CXCursorVisitor visitor, 2996 CXClientData client_data) { 2997 CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data, 2998 /*VisitPreprocessorLast=*/false); 2999 return CursorVis.VisitChildren(parent); 3000} 3001 3002#ifndef __has_feature 3003#define __has_feature(x) 0 3004#endif 3005#if __has_feature(blocks) 3006typedef enum CXChildVisitResult 3007 (^CXCursorVisitorBlock)(CXCursor cursor, CXCursor parent); 3008 3009static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 3010 CXClientData client_data) { 3011 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 3012 return block(cursor, parent); 3013} 3014#else 3015// If we are compiled with a compiler that doesn't have native blocks support, 3016// define and call the block manually, so the 3017typedef struct _CXChildVisitResult 3018{ 3019 void *isa; 3020 int flags; 3021 int reserved; 3022 enum CXChildVisitResult(*invoke)(struct _CXChildVisitResult*, CXCursor, 3023 CXCursor); 3024} *CXCursorVisitorBlock; 3025 3026static enum CXChildVisitResult visitWithBlock(CXCursor cursor, CXCursor parent, 3027 CXClientData client_data) { 3028 CXCursorVisitorBlock block = (CXCursorVisitorBlock)client_data; 3029 return block->invoke(block, cursor, parent); 3030} 3031#endif 3032 3033 3034unsigned clang_visitChildrenWithBlock(CXCursor parent, 3035 CXCursorVisitorBlock block) { 3036 return clang_visitChildren(parent, visitWithBlock, block); 3037} 3038 3039static CXString getDeclSpelling(Decl *D) { 3040 if (!D) 3041 return createCXString(""); 3042 3043 NamedDecl *ND = dyn_cast<NamedDecl>(D); 3044 if (!ND) { 3045 if (ObjCPropertyImplDecl *PropImpl =dyn_cast<ObjCPropertyImplDecl>(D)) 3046 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 3047 return createCXString(Property->getIdentifier()->getName()); 3048 3049 return createCXString(""); 3050 } 3051 3052 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND)) 3053 return createCXString(OMD->getSelector().getAsString()); 3054 3055 if (ObjCCategoryImplDecl *CIMP = dyn_cast<ObjCCategoryImplDecl>(ND)) 3056 // No, this isn't the same as the code below. getIdentifier() is non-virtual 3057 // and returns different names. NamedDecl returns the class name and 3058 // ObjCCategoryImplDecl returns the category name. 3059 return createCXString(CIMP->getIdentifier()->getNameStart()); 3060 3061 if (isa<UsingDirectiveDecl>(D)) 3062 return createCXString(""); 3063 3064 SmallString<1024> S; 3065 llvm::raw_svector_ostream os(S); 3066 ND->printName(os); 3067 3068 return createCXString(os.str()); 3069} 3070 3071CXString clang_getCursorSpelling(CXCursor C) { 3072 if (clang_isTranslationUnit(C.kind)) 3073 return clang_getTranslationUnitSpelling( 3074 static_cast<CXTranslationUnit>(C.data[2])); 3075 3076 if (clang_isReference(C.kind)) { 3077 switch (C.kind) { 3078 case CXCursor_ObjCSuperClassRef: { 3079 ObjCInterfaceDecl *Super = getCursorObjCSuperClassRef(C).first; 3080 return createCXString(Super->getIdentifier()->getNameStart()); 3081 } 3082 case CXCursor_ObjCClassRef: { 3083 ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first; 3084 return createCXString(Class->getIdentifier()->getNameStart()); 3085 } 3086 case CXCursor_ObjCProtocolRef: { 3087 ObjCProtocolDecl *OID = getCursorObjCProtocolRef(C).first; 3088 assert(OID && "getCursorSpelling(): Missing protocol decl"); 3089 return createCXString(OID->getIdentifier()->getNameStart()); 3090 } 3091 case CXCursor_CXXBaseSpecifier: { 3092 CXXBaseSpecifier *B = getCursorCXXBaseSpecifier(C); 3093 return createCXString(B->getType().getAsString()); 3094 } 3095 case CXCursor_TypeRef: { 3096 TypeDecl *Type = getCursorTypeRef(C).first; 3097 assert(Type && "Missing type decl"); 3098 3099 return createCXString(getCursorContext(C).getTypeDeclType(Type). 3100 getAsString()); 3101 } 3102 case CXCursor_TemplateRef: { 3103 TemplateDecl *Template = getCursorTemplateRef(C).first; 3104 assert(Template && "Missing template decl"); 3105 3106 return createCXString(Template->getNameAsString()); 3107 } 3108 3109 case CXCursor_NamespaceRef: { 3110 NamedDecl *NS = getCursorNamespaceRef(C).first; 3111 assert(NS && "Missing namespace decl"); 3112 3113 return createCXString(NS->getNameAsString()); 3114 } 3115 3116 case CXCursor_MemberRef: { 3117 FieldDecl *Field = getCursorMemberRef(C).first; 3118 assert(Field && "Missing member decl"); 3119 3120 return createCXString(Field->getNameAsString()); 3121 } 3122 3123 case CXCursor_LabelRef: { 3124 LabelStmt *Label = getCursorLabelRef(C).first; 3125 assert(Label && "Missing label"); 3126 3127 return createCXString(Label->getName()); 3128 } 3129 3130 case CXCursor_OverloadedDeclRef: { 3131 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 3132 if (Decl *D = Storage.dyn_cast<Decl *>()) { 3133 if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) 3134 return createCXString(ND->getNameAsString()); 3135 return createCXString(""); 3136 } 3137 if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>()) 3138 return createCXString(E->getName().getAsString()); 3139 OverloadedTemplateStorage *Ovl 3140 = Storage.get<OverloadedTemplateStorage*>(); 3141 if (Ovl->size() == 0) 3142 return createCXString(""); 3143 return createCXString((*Ovl->begin())->getNameAsString()); 3144 } 3145 3146 case CXCursor_VariableRef: { 3147 VarDecl *Var = getCursorVariableRef(C).first; 3148 assert(Var && "Missing variable decl"); 3149 3150 return createCXString(Var->getNameAsString()); 3151 } 3152 3153 default: 3154 return createCXString("<not implemented>"); 3155 } 3156 } 3157 3158 if (clang_isExpression(C.kind)) { 3159 Decl *D = getDeclFromExpr(getCursorExpr(C)); 3160 if (D) 3161 return getDeclSpelling(D); 3162 return createCXString(""); 3163 } 3164 3165 if (clang_isStatement(C.kind)) { 3166 Stmt *S = getCursorStmt(C); 3167 if (LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) 3168 return createCXString(Label->getName()); 3169 3170 return createCXString(""); 3171 } 3172 3173 if (C.kind == CXCursor_MacroExpansion) 3174 return createCXString(getCursorMacroExpansion(C)->getName() 3175 ->getNameStart()); 3176 3177 if (C.kind == CXCursor_MacroDefinition) 3178 return createCXString(getCursorMacroDefinition(C)->getName() 3179 ->getNameStart()); 3180 3181 if (C.kind == CXCursor_InclusionDirective) 3182 return createCXString(getCursorInclusionDirective(C)->getFileName()); 3183 3184 if (clang_isDeclaration(C.kind)) 3185 return getDeclSpelling(getCursorDecl(C)); 3186 3187 if (C.kind == CXCursor_AnnotateAttr) { 3188 AnnotateAttr *AA = cast<AnnotateAttr>(cxcursor::getCursorAttr(C)); 3189 return createCXString(AA->getAnnotation()); 3190 } 3191 3192 if (C.kind == CXCursor_AsmLabelAttr) { 3193 AsmLabelAttr *AA = cast<AsmLabelAttr>(cxcursor::getCursorAttr(C)); 3194 return createCXString(AA->getLabel()); 3195 } 3196 3197 return createCXString(""); 3198} 3199 3200CXSourceRange clang_Cursor_getSpellingNameRange(CXCursor C, 3201 unsigned pieceIndex, 3202 unsigned options) { 3203 if (clang_Cursor_isNull(C)) 3204 return clang_getNullRange(); 3205 3206 ASTContext &Ctx = getCursorContext(C); 3207 3208 if (clang_isStatement(C.kind)) { 3209 Stmt *S = getCursorStmt(C); 3210 if (LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S)) { 3211 if (pieceIndex > 0) 3212 return clang_getNullRange(); 3213 return cxloc::translateSourceRange(Ctx, Label->getIdentLoc()); 3214 } 3215 3216 return clang_getNullRange(); 3217 } 3218 3219 if (C.kind == CXCursor_ObjCMessageExpr) { 3220 if (ObjCMessageExpr * 3221 ME = dyn_cast_or_null<ObjCMessageExpr>(getCursorExpr(C))) { 3222 if (pieceIndex >= ME->getNumSelectorLocs()) 3223 return clang_getNullRange(); 3224 return cxloc::translateSourceRange(Ctx, ME->getSelectorLoc(pieceIndex)); 3225 } 3226 } 3227 3228 if (C.kind == CXCursor_ObjCInstanceMethodDecl || 3229 C.kind == CXCursor_ObjCClassMethodDecl) { 3230 if (ObjCMethodDecl * 3231 MD = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(C))) { 3232 if (pieceIndex >= MD->getNumSelectorLocs()) 3233 return clang_getNullRange(); 3234 return cxloc::translateSourceRange(Ctx, MD->getSelectorLoc(pieceIndex)); 3235 } 3236 } 3237 3238 if (C.kind == CXCursor_ObjCCategoryDecl || 3239 C.kind == CXCursor_ObjCCategoryImplDecl) { 3240 if (pieceIndex > 0) 3241 return clang_getNullRange(); 3242 if (ObjCCategoryDecl * 3243 CD = dyn_cast_or_null<ObjCCategoryDecl>(getCursorDecl(C))) 3244 return cxloc::translateSourceRange(Ctx, CD->getCategoryNameLoc()); 3245 if (ObjCCategoryImplDecl * 3246 CID = dyn_cast_or_null<ObjCCategoryImplDecl>(getCursorDecl(C))) 3247 return cxloc::translateSourceRange(Ctx, CID->getCategoryNameLoc()); 3248 } 3249 3250 // FIXME: A CXCursor_InclusionDirective should give the location of the 3251 // filename, but we don't keep track of this. 3252 3253 // FIXME: A CXCursor_AnnotateAttr should give the location of the annotation 3254 // but we don't keep track of this. 3255 3256 // FIXME: A CXCursor_AsmLabelAttr should give the location of the label 3257 // but we don't keep track of this. 3258 3259 // Default handling, give the location of the cursor. 3260 3261 if (pieceIndex > 0) 3262 return clang_getNullRange(); 3263 3264 CXSourceLocation CXLoc = clang_getCursorLocation(C); 3265 SourceLocation Loc = cxloc::translateSourceLocation(CXLoc); 3266 return cxloc::translateSourceRange(Ctx, Loc); 3267} 3268 3269CXString clang_getCursorDisplayName(CXCursor C) { 3270 if (!clang_isDeclaration(C.kind)) 3271 return clang_getCursorSpelling(C); 3272 3273 Decl *D = getCursorDecl(C); 3274 if (!D) 3275 return createCXString(""); 3276 3277 PrintingPolicy Policy = getCursorContext(C).getPrintingPolicy(); 3278 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) 3279 D = FunTmpl->getTemplatedDecl(); 3280 3281 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 3282 SmallString<64> Str; 3283 llvm::raw_svector_ostream OS(Str); 3284 OS << *Function; 3285 if (Function->getPrimaryTemplate()) 3286 OS << "<>"; 3287 OS << "("; 3288 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) { 3289 if (I) 3290 OS << ", "; 3291 OS << Function->getParamDecl(I)->getType().getAsString(Policy); 3292 } 3293 3294 if (Function->isVariadic()) { 3295 if (Function->getNumParams()) 3296 OS << ", "; 3297 OS << "..."; 3298 } 3299 OS << ")"; 3300 return createCXString(OS.str()); 3301 } 3302 3303 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) { 3304 SmallString<64> Str; 3305 llvm::raw_svector_ostream OS(Str); 3306 OS << *ClassTemplate; 3307 OS << "<"; 3308 TemplateParameterList *Params = ClassTemplate->getTemplateParameters(); 3309 for (unsigned I = 0, N = Params->size(); I != N; ++I) { 3310 if (I) 3311 OS << ", "; 3312 3313 NamedDecl *Param = Params->getParam(I); 3314 if (Param->getIdentifier()) { 3315 OS << Param->getIdentifier()->getName(); 3316 continue; 3317 } 3318 3319 // There is no parameter name, which makes this tricky. Try to come up 3320 // with something useful that isn't too long. 3321 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 3322 OS << (TTP->wasDeclaredWithTypename()? "typename" : "class"); 3323 else if (NonTypeTemplateParmDecl *NTTP 3324 = dyn_cast<NonTypeTemplateParmDecl>(Param)) 3325 OS << NTTP->getType().getAsString(Policy); 3326 else 3327 OS << "template<...> class"; 3328 } 3329 3330 OS << ">"; 3331 return createCXString(OS.str()); 3332 } 3333 3334 if (ClassTemplateSpecializationDecl *ClassSpec 3335 = dyn_cast<ClassTemplateSpecializationDecl>(D)) { 3336 // If the type was explicitly written, use that. 3337 if (TypeSourceInfo *TSInfo = ClassSpec->getTypeAsWritten()) 3338 return createCXString(TSInfo->getType().getAsString(Policy)); 3339 3340 SmallString<64> Str; 3341 llvm::raw_svector_ostream OS(Str); 3342 OS << *ClassSpec; 3343 OS << TemplateSpecializationType::PrintTemplateArgumentList( 3344 ClassSpec->getTemplateArgs().data(), 3345 ClassSpec->getTemplateArgs().size(), 3346 Policy); 3347 return createCXString(OS.str()); 3348 } 3349 3350 return clang_getCursorSpelling(C); 3351} 3352 3353CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) { 3354 switch (Kind) { 3355 case CXCursor_FunctionDecl: 3356 return createCXString("FunctionDecl"); 3357 case CXCursor_TypedefDecl: 3358 return createCXString("TypedefDecl"); 3359 case CXCursor_EnumDecl: 3360 return createCXString("EnumDecl"); 3361 case CXCursor_EnumConstantDecl: 3362 return createCXString("EnumConstantDecl"); 3363 case CXCursor_StructDecl: 3364 return createCXString("StructDecl"); 3365 case CXCursor_UnionDecl: 3366 return createCXString("UnionDecl"); 3367 case CXCursor_ClassDecl: 3368 return createCXString("ClassDecl"); 3369 case CXCursor_FieldDecl: 3370 return createCXString("FieldDecl"); 3371 case CXCursor_VarDecl: 3372 return createCXString("VarDecl"); 3373 case CXCursor_ParmDecl: 3374 return createCXString("ParmDecl"); 3375 case CXCursor_ObjCInterfaceDecl: 3376 return createCXString("ObjCInterfaceDecl"); 3377 case CXCursor_ObjCCategoryDecl: 3378 return createCXString("ObjCCategoryDecl"); 3379 case CXCursor_ObjCProtocolDecl: 3380 return createCXString("ObjCProtocolDecl"); 3381 case CXCursor_ObjCPropertyDecl: 3382 return createCXString("ObjCPropertyDecl"); 3383 case CXCursor_ObjCIvarDecl: 3384 return createCXString("ObjCIvarDecl"); 3385 case CXCursor_ObjCInstanceMethodDecl: 3386 return createCXString("ObjCInstanceMethodDecl"); 3387 case CXCursor_ObjCClassMethodDecl: 3388 return createCXString("ObjCClassMethodDecl"); 3389 case CXCursor_ObjCImplementationDecl: 3390 return createCXString("ObjCImplementationDecl"); 3391 case CXCursor_ObjCCategoryImplDecl: 3392 return createCXString("ObjCCategoryImplDecl"); 3393 case CXCursor_CXXMethod: 3394 return createCXString("CXXMethod"); 3395 case CXCursor_UnexposedDecl: 3396 return createCXString("UnexposedDecl"); 3397 case CXCursor_ObjCSuperClassRef: 3398 return createCXString("ObjCSuperClassRef"); 3399 case CXCursor_ObjCProtocolRef: 3400 return createCXString("ObjCProtocolRef"); 3401 case CXCursor_ObjCClassRef: 3402 return createCXString("ObjCClassRef"); 3403 case CXCursor_TypeRef: 3404 return createCXString("TypeRef"); 3405 case CXCursor_TemplateRef: 3406 return createCXString("TemplateRef"); 3407 case CXCursor_NamespaceRef: 3408 return createCXString("NamespaceRef"); 3409 case CXCursor_MemberRef: 3410 return createCXString("MemberRef"); 3411 case CXCursor_LabelRef: 3412 return createCXString("LabelRef"); 3413 case CXCursor_OverloadedDeclRef: 3414 return createCXString("OverloadedDeclRef"); 3415 case CXCursor_VariableRef: 3416 return createCXString("VariableRef"); 3417 case CXCursor_IntegerLiteral: 3418 return createCXString("IntegerLiteral"); 3419 case CXCursor_FloatingLiteral: 3420 return createCXString("FloatingLiteral"); 3421 case CXCursor_ImaginaryLiteral: 3422 return createCXString("ImaginaryLiteral"); 3423 case CXCursor_StringLiteral: 3424 return createCXString("StringLiteral"); 3425 case CXCursor_CharacterLiteral: 3426 return createCXString("CharacterLiteral"); 3427 case CXCursor_ParenExpr: 3428 return createCXString("ParenExpr"); 3429 case CXCursor_UnaryOperator: 3430 return createCXString("UnaryOperator"); 3431 case CXCursor_ArraySubscriptExpr: 3432 return createCXString("ArraySubscriptExpr"); 3433 case CXCursor_BinaryOperator: 3434 return createCXString("BinaryOperator"); 3435 case CXCursor_CompoundAssignOperator: 3436 return createCXString("CompoundAssignOperator"); 3437 case CXCursor_ConditionalOperator: 3438 return createCXString("ConditionalOperator"); 3439 case CXCursor_CStyleCastExpr: 3440 return createCXString("CStyleCastExpr"); 3441 case CXCursor_CompoundLiteralExpr: 3442 return createCXString("CompoundLiteralExpr"); 3443 case CXCursor_InitListExpr: 3444 return createCXString("InitListExpr"); 3445 case CXCursor_AddrLabelExpr: 3446 return createCXString("AddrLabelExpr"); 3447 case CXCursor_StmtExpr: 3448 return createCXString("StmtExpr"); 3449 case CXCursor_GenericSelectionExpr: 3450 return createCXString("GenericSelectionExpr"); 3451 case CXCursor_GNUNullExpr: 3452 return createCXString("GNUNullExpr"); 3453 case CXCursor_CXXStaticCastExpr: 3454 return createCXString("CXXStaticCastExpr"); 3455 case CXCursor_CXXDynamicCastExpr: 3456 return createCXString("CXXDynamicCastExpr"); 3457 case CXCursor_CXXReinterpretCastExpr: 3458 return createCXString("CXXReinterpretCastExpr"); 3459 case CXCursor_CXXConstCastExpr: 3460 return createCXString("CXXConstCastExpr"); 3461 case CXCursor_CXXFunctionalCastExpr: 3462 return createCXString("CXXFunctionalCastExpr"); 3463 case CXCursor_CXXTypeidExpr: 3464 return createCXString("CXXTypeidExpr"); 3465 case CXCursor_CXXBoolLiteralExpr: 3466 return createCXString("CXXBoolLiteralExpr"); 3467 case CXCursor_CXXNullPtrLiteralExpr: 3468 return createCXString("CXXNullPtrLiteralExpr"); 3469 case CXCursor_CXXThisExpr: 3470 return createCXString("CXXThisExpr"); 3471 case CXCursor_CXXThrowExpr: 3472 return createCXString("CXXThrowExpr"); 3473 case CXCursor_CXXNewExpr: 3474 return createCXString("CXXNewExpr"); 3475 case CXCursor_CXXDeleteExpr: 3476 return createCXString("CXXDeleteExpr"); 3477 case CXCursor_UnaryExpr: 3478 return createCXString("UnaryExpr"); 3479 case CXCursor_ObjCStringLiteral: 3480 return createCXString("ObjCStringLiteral"); 3481 case CXCursor_ObjCBoolLiteralExpr: 3482 return createCXString("ObjCBoolLiteralExpr"); 3483 case CXCursor_ObjCEncodeExpr: 3484 return createCXString("ObjCEncodeExpr"); 3485 case CXCursor_ObjCSelectorExpr: 3486 return createCXString("ObjCSelectorExpr"); 3487 case CXCursor_ObjCProtocolExpr: 3488 return createCXString("ObjCProtocolExpr"); 3489 case CXCursor_ObjCBridgedCastExpr: 3490 return createCXString("ObjCBridgedCastExpr"); 3491 case CXCursor_BlockExpr: 3492 return createCXString("BlockExpr"); 3493 case CXCursor_PackExpansionExpr: 3494 return createCXString("PackExpansionExpr"); 3495 case CXCursor_SizeOfPackExpr: 3496 return createCXString("SizeOfPackExpr"); 3497 case CXCursor_LambdaExpr: 3498 return createCXString("LambdaExpr"); 3499 case CXCursor_UnexposedExpr: 3500 return createCXString("UnexposedExpr"); 3501 case CXCursor_DeclRefExpr: 3502 return createCXString("DeclRefExpr"); 3503 case CXCursor_MemberRefExpr: 3504 return createCXString("MemberRefExpr"); 3505 case CXCursor_CallExpr: 3506 return createCXString("CallExpr"); 3507 case CXCursor_ObjCMessageExpr: 3508 return createCXString("ObjCMessageExpr"); 3509 case CXCursor_UnexposedStmt: 3510 return createCXString("UnexposedStmt"); 3511 case CXCursor_DeclStmt: 3512 return createCXString("DeclStmt"); 3513 case CXCursor_LabelStmt: 3514 return createCXString("LabelStmt"); 3515 case CXCursor_CompoundStmt: 3516 return createCXString("CompoundStmt"); 3517 case CXCursor_CaseStmt: 3518 return createCXString("CaseStmt"); 3519 case CXCursor_DefaultStmt: 3520 return createCXString("DefaultStmt"); 3521 case CXCursor_IfStmt: 3522 return createCXString("IfStmt"); 3523 case CXCursor_SwitchStmt: 3524 return createCXString("SwitchStmt"); 3525 case CXCursor_WhileStmt: 3526 return createCXString("WhileStmt"); 3527 case CXCursor_DoStmt: 3528 return createCXString("DoStmt"); 3529 case CXCursor_ForStmt: 3530 return createCXString("ForStmt"); 3531 case CXCursor_GotoStmt: 3532 return createCXString("GotoStmt"); 3533 case CXCursor_IndirectGotoStmt: 3534 return createCXString("IndirectGotoStmt"); 3535 case CXCursor_ContinueStmt: 3536 return createCXString("ContinueStmt"); 3537 case CXCursor_BreakStmt: 3538 return createCXString("BreakStmt"); 3539 case CXCursor_ReturnStmt: 3540 return createCXString("ReturnStmt"); 3541 case CXCursor_GCCAsmStmt: 3542 return createCXString("GCCAsmStmt"); 3543 case CXCursor_MSAsmStmt: 3544 return createCXString("MSAsmStmt"); 3545 case CXCursor_ObjCAtTryStmt: 3546 return createCXString("ObjCAtTryStmt"); 3547 case CXCursor_ObjCAtCatchStmt: 3548 return createCXString("ObjCAtCatchStmt"); 3549 case CXCursor_ObjCAtFinallyStmt: 3550 return createCXString("ObjCAtFinallyStmt"); 3551 case CXCursor_ObjCAtThrowStmt: 3552 return createCXString("ObjCAtThrowStmt"); 3553 case CXCursor_ObjCAtSynchronizedStmt: 3554 return createCXString("ObjCAtSynchronizedStmt"); 3555 case CXCursor_ObjCAutoreleasePoolStmt: 3556 return createCXString("ObjCAutoreleasePoolStmt"); 3557 case CXCursor_ObjCForCollectionStmt: 3558 return createCXString("ObjCForCollectionStmt"); 3559 case CXCursor_CXXCatchStmt: 3560 return createCXString("CXXCatchStmt"); 3561 case CXCursor_CXXTryStmt: 3562 return createCXString("CXXTryStmt"); 3563 case CXCursor_CXXForRangeStmt: 3564 return createCXString("CXXForRangeStmt"); 3565 case CXCursor_SEHTryStmt: 3566 return createCXString("SEHTryStmt"); 3567 case CXCursor_SEHExceptStmt: 3568 return createCXString("SEHExceptStmt"); 3569 case CXCursor_SEHFinallyStmt: 3570 return createCXString("SEHFinallyStmt"); 3571 case CXCursor_NullStmt: 3572 return createCXString("NullStmt"); 3573 case CXCursor_InvalidFile: 3574 return createCXString("InvalidFile"); 3575 case CXCursor_InvalidCode: 3576 return createCXString("InvalidCode"); 3577 case CXCursor_NoDeclFound: 3578 return createCXString("NoDeclFound"); 3579 case CXCursor_NotImplemented: 3580 return createCXString("NotImplemented"); 3581 case CXCursor_TranslationUnit: 3582 return createCXString("TranslationUnit"); 3583 case CXCursor_UnexposedAttr: 3584 return createCXString("UnexposedAttr"); 3585 case CXCursor_IBActionAttr: 3586 return createCXString("attribute(ibaction)"); 3587 case CXCursor_IBOutletAttr: 3588 return createCXString("attribute(iboutlet)"); 3589 case CXCursor_IBOutletCollectionAttr: 3590 return createCXString("attribute(iboutletcollection)"); 3591 case CXCursor_CXXFinalAttr: 3592 return createCXString("attribute(final)"); 3593 case CXCursor_CXXOverrideAttr: 3594 return createCXString("attribute(override)"); 3595 case CXCursor_AnnotateAttr: 3596 return createCXString("attribute(annotate)"); 3597 case CXCursor_AsmLabelAttr: 3598 return createCXString("asm label"); 3599 case CXCursor_PreprocessingDirective: 3600 return createCXString("preprocessing directive"); 3601 case CXCursor_MacroDefinition: 3602 return createCXString("macro definition"); 3603 case CXCursor_MacroExpansion: 3604 return createCXString("macro expansion"); 3605 case CXCursor_InclusionDirective: 3606 return createCXString("inclusion directive"); 3607 case CXCursor_Namespace: 3608 return createCXString("Namespace"); 3609 case CXCursor_LinkageSpec: 3610 return createCXString("LinkageSpec"); 3611 case CXCursor_CXXBaseSpecifier: 3612 return createCXString("C++ base class specifier"); 3613 case CXCursor_Constructor: 3614 return createCXString("CXXConstructor"); 3615 case CXCursor_Destructor: 3616 return createCXString("CXXDestructor"); 3617 case CXCursor_ConversionFunction: 3618 return createCXString("CXXConversion"); 3619 case CXCursor_TemplateTypeParameter: 3620 return createCXString("TemplateTypeParameter"); 3621 case CXCursor_NonTypeTemplateParameter: 3622 return createCXString("NonTypeTemplateParameter"); 3623 case CXCursor_TemplateTemplateParameter: 3624 return createCXString("TemplateTemplateParameter"); 3625 case CXCursor_FunctionTemplate: 3626 return createCXString("FunctionTemplate"); 3627 case CXCursor_ClassTemplate: 3628 return createCXString("ClassTemplate"); 3629 case CXCursor_ClassTemplatePartialSpecialization: 3630 return createCXString("ClassTemplatePartialSpecialization"); 3631 case CXCursor_NamespaceAlias: 3632 return createCXString("NamespaceAlias"); 3633 case CXCursor_UsingDirective: 3634 return createCXString("UsingDirective"); 3635 case CXCursor_UsingDeclaration: 3636 return createCXString("UsingDeclaration"); 3637 case CXCursor_TypeAliasDecl: 3638 return createCXString("TypeAliasDecl"); 3639 case CXCursor_ObjCSynthesizeDecl: 3640 return createCXString("ObjCSynthesizeDecl"); 3641 case CXCursor_ObjCDynamicDecl: 3642 return createCXString("ObjCDynamicDecl"); 3643 case CXCursor_CXXAccessSpecifier: 3644 return createCXString("CXXAccessSpecifier"); 3645 } 3646 3647 llvm_unreachable("Unhandled CXCursorKind"); 3648} 3649 3650struct GetCursorData { 3651 SourceLocation TokenBeginLoc; 3652 bool PointsAtMacroArgExpansion; 3653 bool VisitedObjCPropertyImplDecl; 3654 SourceLocation VisitedDeclaratorDeclStartLoc; 3655 CXCursor &BestCursor; 3656 3657 GetCursorData(SourceManager &SM, 3658 SourceLocation tokenBegin, CXCursor &outputCursor) 3659 : TokenBeginLoc(tokenBegin), BestCursor(outputCursor) { 3660 PointsAtMacroArgExpansion = SM.isMacroArgExpansion(tokenBegin); 3661 VisitedObjCPropertyImplDecl = false; 3662 } 3663}; 3664 3665static enum CXChildVisitResult GetCursorVisitor(CXCursor cursor, 3666 CXCursor parent, 3667 CXClientData client_data) { 3668 GetCursorData *Data = static_cast<GetCursorData *>(client_data); 3669 CXCursor *BestCursor = &Data->BestCursor; 3670 3671 // If we point inside a macro argument we should provide info of what the 3672 // token is so use the actual cursor, don't replace it with a macro expansion 3673 // cursor. 3674 if (cursor.kind == CXCursor_MacroExpansion && Data->PointsAtMacroArgExpansion) 3675 return CXChildVisit_Recurse; 3676 3677 if (clang_isDeclaration(cursor.kind)) { 3678 // Avoid having the implicit methods override the property decls. 3679 if (ObjCMethodDecl *MD 3680 = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) { 3681 if (MD->isImplicit()) 3682 return CXChildVisit_Break; 3683 3684 } else if (ObjCInterfaceDecl *ID 3685 = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(cursor))) { 3686 // Check that when we have multiple @class references in the same line, 3687 // that later ones do not override the previous ones. 3688 // If we have: 3689 // @class Foo, Bar; 3690 // source ranges for both start at '@', so 'Bar' will end up overriding 3691 // 'Foo' even though the cursor location was at 'Foo'. 3692 if (BestCursor->kind == CXCursor_ObjCInterfaceDecl || 3693 BestCursor->kind == CXCursor_ObjCClassRef) 3694 if (ObjCInterfaceDecl *PrevID 3695 = dyn_cast_or_null<ObjCInterfaceDecl>(getCursorDecl(*BestCursor))){ 3696 if (PrevID != ID && 3697 !PrevID->isThisDeclarationADefinition() && 3698 !ID->isThisDeclarationADefinition()) 3699 return CXChildVisit_Break; 3700 } 3701 3702 } else if (DeclaratorDecl *DD 3703 = dyn_cast_or_null<DeclaratorDecl>(getCursorDecl(cursor))) { 3704 SourceLocation StartLoc = DD->getSourceRange().getBegin(); 3705 // Check that when we have multiple declarators in the same line, 3706 // that later ones do not override the previous ones. 3707 // If we have: 3708 // int Foo, Bar; 3709 // source ranges for both start at 'int', so 'Bar' will end up overriding 3710 // 'Foo' even though the cursor location was at 'Foo'. 3711 if (Data->VisitedDeclaratorDeclStartLoc == StartLoc) 3712 return CXChildVisit_Break; 3713 Data->VisitedDeclaratorDeclStartLoc = StartLoc; 3714 3715 } else if (ObjCPropertyImplDecl *PropImp 3716 = dyn_cast_or_null<ObjCPropertyImplDecl>(getCursorDecl(cursor))) { 3717 (void)PropImp; 3718 // Check that when we have multiple @synthesize in the same line, 3719 // that later ones do not override the previous ones. 3720 // If we have: 3721 // @synthesize Foo, Bar; 3722 // source ranges for both start at '@', so 'Bar' will end up overriding 3723 // 'Foo' even though the cursor location was at 'Foo'. 3724 if (Data->VisitedObjCPropertyImplDecl) 3725 return CXChildVisit_Break; 3726 Data->VisitedObjCPropertyImplDecl = true; 3727 } 3728 } 3729 3730 if (clang_isExpression(cursor.kind) && 3731 clang_isDeclaration(BestCursor->kind)) { 3732 if (Decl *D = getCursorDecl(*BestCursor)) { 3733 // Avoid having the cursor of an expression replace the declaration cursor 3734 // when the expression source range overlaps the declaration range. 3735 // This can happen for C++ constructor expressions whose range generally 3736 // include the variable declaration, e.g.: 3737 // MyCXXClass foo; // Make sure pointing at 'foo' returns a VarDecl cursor. 3738 if (D->getLocation().isValid() && Data->TokenBeginLoc.isValid() && 3739 D->getLocation() == Data->TokenBeginLoc) 3740 return CXChildVisit_Break; 3741 } 3742 } 3743 3744 // If our current best cursor is the construction of a temporary object, 3745 // don't replace that cursor with a type reference, because we want 3746 // clang_getCursor() to point at the constructor. 3747 if (clang_isExpression(BestCursor->kind) && 3748 isa<CXXTemporaryObjectExpr>(getCursorExpr(*BestCursor)) && 3749 cursor.kind == CXCursor_TypeRef) { 3750 // Keep the cursor pointing at CXXTemporaryObjectExpr but also mark it 3751 // as having the actual point on the type reference. 3752 *BestCursor = getTypeRefedCallExprCursor(*BestCursor); 3753 return CXChildVisit_Recurse; 3754 } 3755 3756 *BestCursor = cursor; 3757 return CXChildVisit_Recurse; 3758} 3759 3760CXCursor clang_getCursor(CXTranslationUnit TU, CXSourceLocation Loc) { 3761 if (!TU) 3762 return clang_getNullCursor(); 3763 3764 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 3765 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 3766 3767 SourceLocation SLoc = cxloc::translateSourceLocation(Loc); 3768 CXCursor Result = cxcursor::getCursor(TU, SLoc); 3769 3770 bool Logging = getenv("LIBCLANG_LOGGING"); 3771 if (Logging) { 3772 CXFile SearchFile; 3773 unsigned SearchLine, SearchColumn; 3774 CXFile ResultFile; 3775 unsigned ResultLine, ResultColumn; 3776 CXString SearchFileName, ResultFileName, KindSpelling, USR; 3777 const char *IsDef = clang_isCursorDefinition(Result)? " (Definition)" : ""; 3778 CXSourceLocation ResultLoc = clang_getCursorLocation(Result); 3779 3780 clang_getExpansionLocation(Loc, &SearchFile, &SearchLine, &SearchColumn, 0); 3781 clang_getExpansionLocation(ResultLoc, &ResultFile, &ResultLine, 3782 &ResultColumn, 0); 3783 SearchFileName = clang_getFileName(SearchFile); 3784 ResultFileName = clang_getFileName(ResultFile); 3785 KindSpelling = clang_getCursorKindSpelling(Result.kind); 3786 USR = clang_getCursorUSR(Result); 3787 fprintf(stderr, "clang_getCursor(%s:%d:%d) = %s(%s:%d:%d):%s%s\n", 3788 clang_getCString(SearchFileName), SearchLine, SearchColumn, 3789 clang_getCString(KindSpelling), 3790 clang_getCString(ResultFileName), ResultLine, ResultColumn, 3791 clang_getCString(USR), IsDef); 3792 clang_disposeString(SearchFileName); 3793 clang_disposeString(ResultFileName); 3794 clang_disposeString(KindSpelling); 3795 clang_disposeString(USR); 3796 3797 CXCursor Definition = clang_getCursorDefinition(Result); 3798 if (!clang_equalCursors(Definition, clang_getNullCursor())) { 3799 CXSourceLocation DefinitionLoc = clang_getCursorLocation(Definition); 3800 CXString DefinitionKindSpelling 3801 = clang_getCursorKindSpelling(Definition.kind); 3802 CXFile DefinitionFile; 3803 unsigned DefinitionLine, DefinitionColumn; 3804 clang_getExpansionLocation(DefinitionLoc, &DefinitionFile, 3805 &DefinitionLine, &DefinitionColumn, 0); 3806 CXString DefinitionFileName = clang_getFileName(DefinitionFile); 3807 fprintf(stderr, " -> %s(%s:%d:%d)\n", 3808 clang_getCString(DefinitionKindSpelling), 3809 clang_getCString(DefinitionFileName), 3810 DefinitionLine, DefinitionColumn); 3811 clang_disposeString(DefinitionFileName); 3812 clang_disposeString(DefinitionKindSpelling); 3813 } 3814 } 3815 3816 return Result; 3817} 3818 3819CXCursor clang_getNullCursor(void) { 3820 return MakeCXCursorInvalid(CXCursor_InvalidFile); 3821} 3822 3823unsigned clang_equalCursors(CXCursor X, CXCursor Y) { 3824 return X == Y; 3825} 3826 3827unsigned clang_hashCursor(CXCursor C) { 3828 unsigned Index = 0; 3829 if (clang_isExpression(C.kind) || clang_isStatement(C.kind)) 3830 Index = 1; 3831 3832 return llvm::DenseMapInfo<std::pair<unsigned, void*> >::getHashValue( 3833 std::make_pair(C.kind, C.data[Index])); 3834} 3835 3836unsigned clang_isInvalid(enum CXCursorKind K) { 3837 return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid; 3838} 3839 3840unsigned clang_isDeclaration(enum CXCursorKind K) { 3841 return K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl; 3842} 3843 3844unsigned clang_isReference(enum CXCursorKind K) { 3845 return K >= CXCursor_FirstRef && K <= CXCursor_LastRef; 3846} 3847 3848unsigned clang_isExpression(enum CXCursorKind K) { 3849 return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr; 3850} 3851 3852unsigned clang_isStatement(enum CXCursorKind K) { 3853 return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt; 3854} 3855 3856unsigned clang_isAttribute(enum CXCursorKind K) { 3857 return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr; 3858} 3859 3860unsigned clang_isTranslationUnit(enum CXCursorKind K) { 3861 return K == CXCursor_TranslationUnit; 3862} 3863 3864unsigned clang_isPreprocessing(enum CXCursorKind K) { 3865 return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing; 3866} 3867 3868unsigned clang_isUnexposed(enum CXCursorKind K) { 3869 switch (K) { 3870 case CXCursor_UnexposedDecl: 3871 case CXCursor_UnexposedExpr: 3872 case CXCursor_UnexposedStmt: 3873 case CXCursor_UnexposedAttr: 3874 return true; 3875 default: 3876 return false; 3877 } 3878} 3879 3880CXCursorKind clang_getCursorKind(CXCursor C) { 3881 return C.kind; 3882} 3883 3884CXSourceLocation clang_getCursorLocation(CXCursor C) { 3885 if (clang_isReference(C.kind)) { 3886 switch (C.kind) { 3887 case CXCursor_ObjCSuperClassRef: { 3888 std::pair<ObjCInterfaceDecl *, SourceLocation> P 3889 = getCursorObjCSuperClassRef(C); 3890 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3891 } 3892 3893 case CXCursor_ObjCProtocolRef: { 3894 std::pair<ObjCProtocolDecl *, SourceLocation> P 3895 = getCursorObjCProtocolRef(C); 3896 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3897 } 3898 3899 case CXCursor_ObjCClassRef: { 3900 std::pair<ObjCInterfaceDecl *, SourceLocation> P 3901 = getCursorObjCClassRef(C); 3902 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3903 } 3904 3905 case CXCursor_TypeRef: { 3906 std::pair<TypeDecl *, SourceLocation> P = getCursorTypeRef(C); 3907 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3908 } 3909 3910 case CXCursor_TemplateRef: { 3911 std::pair<TemplateDecl *, SourceLocation> P = getCursorTemplateRef(C); 3912 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3913 } 3914 3915 case CXCursor_NamespaceRef: { 3916 std::pair<NamedDecl *, SourceLocation> P = getCursorNamespaceRef(C); 3917 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3918 } 3919 3920 case CXCursor_MemberRef: { 3921 std::pair<FieldDecl *, SourceLocation> P = getCursorMemberRef(C); 3922 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3923 } 3924 3925 case CXCursor_VariableRef: { 3926 std::pair<VarDecl *, SourceLocation> P = getCursorVariableRef(C); 3927 return cxloc::translateSourceLocation(P.first->getASTContext(), P.second); 3928 } 3929 3930 case CXCursor_CXXBaseSpecifier: { 3931 CXXBaseSpecifier *BaseSpec = getCursorCXXBaseSpecifier(C); 3932 if (!BaseSpec) 3933 return clang_getNullLocation(); 3934 3935 if (TypeSourceInfo *TSInfo = BaseSpec->getTypeSourceInfo()) 3936 return cxloc::translateSourceLocation(getCursorContext(C), 3937 TSInfo->getTypeLoc().getBeginLoc()); 3938 3939 return cxloc::translateSourceLocation(getCursorContext(C), 3940 BaseSpec->getLocStart()); 3941 } 3942 3943 case CXCursor_LabelRef: { 3944 std::pair<LabelStmt *, SourceLocation> P = getCursorLabelRef(C); 3945 return cxloc::translateSourceLocation(getCursorContext(C), P.second); 3946 } 3947 3948 case CXCursor_OverloadedDeclRef: 3949 return cxloc::translateSourceLocation(getCursorContext(C), 3950 getCursorOverloadedDeclRef(C).second); 3951 3952 default: 3953 // FIXME: Need a way to enumerate all non-reference cases. 3954 llvm_unreachable("Missed a reference kind"); 3955 } 3956 } 3957 3958 if (clang_isExpression(C.kind)) 3959 return cxloc::translateSourceLocation(getCursorContext(C), 3960 getLocationFromExpr(getCursorExpr(C))); 3961 3962 if (clang_isStatement(C.kind)) 3963 return cxloc::translateSourceLocation(getCursorContext(C), 3964 getCursorStmt(C)->getLocStart()); 3965 3966 if (C.kind == CXCursor_PreprocessingDirective) { 3967 SourceLocation L = cxcursor::getCursorPreprocessingDirective(C).getBegin(); 3968 return cxloc::translateSourceLocation(getCursorContext(C), L); 3969 } 3970 3971 if (C.kind == CXCursor_MacroExpansion) { 3972 SourceLocation L 3973 = cxcursor::getCursorMacroExpansion(C)->getSourceRange().getBegin(); 3974 return cxloc::translateSourceLocation(getCursorContext(C), L); 3975 } 3976 3977 if (C.kind == CXCursor_MacroDefinition) { 3978 SourceLocation L = cxcursor::getCursorMacroDefinition(C)->getLocation(); 3979 return cxloc::translateSourceLocation(getCursorContext(C), L); 3980 } 3981 3982 if (C.kind == CXCursor_InclusionDirective) { 3983 SourceLocation L 3984 = cxcursor::getCursorInclusionDirective(C)->getSourceRange().getBegin(); 3985 return cxloc::translateSourceLocation(getCursorContext(C), L); 3986 } 3987 3988 if (C.kind < CXCursor_FirstDecl || C.kind > CXCursor_LastDecl) 3989 return clang_getNullLocation(); 3990 3991 Decl *D = getCursorDecl(C); 3992 if (!D) 3993 return clang_getNullLocation(); 3994 3995 SourceLocation Loc = D->getLocation(); 3996 // FIXME: Multiple variables declared in a single declaration 3997 // currently lack the information needed to correctly determine their 3998 // ranges when accounting for the type-specifier. We use context 3999 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 4000 // and if so, whether it is the first decl. 4001 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 4002 if (!cxcursor::isFirstInDeclGroup(C)) 4003 Loc = VD->getLocation(); 4004 } 4005 4006 // For ObjC methods, give the start location of the method name. 4007 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 4008 Loc = MD->getSelectorStartLoc(); 4009 4010 return cxloc::translateSourceLocation(getCursorContext(C), Loc); 4011} 4012 4013} // end extern "C" 4014 4015CXCursor cxcursor::getCursor(CXTranslationUnit TU, SourceLocation SLoc) { 4016 assert(TU); 4017 4018 // Guard against an invalid SourceLocation, or we may assert in one 4019 // of the following calls. 4020 if (SLoc.isInvalid()) 4021 return clang_getNullCursor(); 4022 4023 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4024 4025 // Translate the given source location to make it point at the beginning of 4026 // the token under the cursor. 4027 SLoc = Lexer::GetBeginningOfToken(SLoc, CXXUnit->getSourceManager(), 4028 CXXUnit->getASTContext().getLangOpts()); 4029 4030 CXCursor Result = MakeCXCursorInvalid(CXCursor_NoDeclFound); 4031 if (SLoc.isValid()) { 4032 GetCursorData ResultData(CXXUnit->getSourceManager(), SLoc, Result); 4033 CursorVisitor CursorVis(TU, GetCursorVisitor, &ResultData, 4034 /*VisitPreprocessorLast=*/true, 4035 /*VisitIncludedEntities=*/false, 4036 SourceLocation(SLoc)); 4037 CursorVis.visitFileRegion(); 4038 } 4039 4040 return Result; 4041} 4042 4043static SourceRange getRawCursorExtent(CXCursor C) { 4044 if (clang_isReference(C.kind)) { 4045 switch (C.kind) { 4046 case CXCursor_ObjCSuperClassRef: 4047 return getCursorObjCSuperClassRef(C).second; 4048 4049 case CXCursor_ObjCProtocolRef: 4050 return getCursorObjCProtocolRef(C).second; 4051 4052 case CXCursor_ObjCClassRef: 4053 return getCursorObjCClassRef(C).second; 4054 4055 case CXCursor_TypeRef: 4056 return getCursorTypeRef(C).second; 4057 4058 case CXCursor_TemplateRef: 4059 return getCursorTemplateRef(C).second; 4060 4061 case CXCursor_NamespaceRef: 4062 return getCursorNamespaceRef(C).second; 4063 4064 case CXCursor_MemberRef: 4065 return getCursorMemberRef(C).second; 4066 4067 case CXCursor_CXXBaseSpecifier: 4068 return getCursorCXXBaseSpecifier(C)->getSourceRange(); 4069 4070 case CXCursor_LabelRef: 4071 return getCursorLabelRef(C).second; 4072 4073 case CXCursor_OverloadedDeclRef: 4074 return getCursorOverloadedDeclRef(C).second; 4075 4076 case CXCursor_VariableRef: 4077 return getCursorVariableRef(C).second; 4078 4079 default: 4080 // FIXME: Need a way to enumerate all non-reference cases. 4081 llvm_unreachable("Missed a reference kind"); 4082 } 4083 } 4084 4085 if (clang_isExpression(C.kind)) 4086 return getCursorExpr(C)->getSourceRange(); 4087 4088 if (clang_isStatement(C.kind)) 4089 return getCursorStmt(C)->getSourceRange(); 4090 4091 if (clang_isAttribute(C.kind)) 4092 return getCursorAttr(C)->getRange(); 4093 4094 if (C.kind == CXCursor_PreprocessingDirective) 4095 return cxcursor::getCursorPreprocessingDirective(C); 4096 4097 if (C.kind == CXCursor_MacroExpansion) { 4098 ASTUnit *TU = getCursorASTUnit(C); 4099 SourceRange Range = cxcursor::getCursorMacroExpansion(C)->getSourceRange(); 4100 return TU->mapRangeFromPreamble(Range); 4101 } 4102 4103 if (C.kind == CXCursor_MacroDefinition) { 4104 ASTUnit *TU = getCursorASTUnit(C); 4105 SourceRange Range = cxcursor::getCursorMacroDefinition(C)->getSourceRange(); 4106 return TU->mapRangeFromPreamble(Range); 4107 } 4108 4109 if (C.kind == CXCursor_InclusionDirective) { 4110 ASTUnit *TU = getCursorASTUnit(C); 4111 SourceRange Range = cxcursor::getCursorInclusionDirective(C)->getSourceRange(); 4112 return TU->mapRangeFromPreamble(Range); 4113 } 4114 4115 if (C.kind == CXCursor_TranslationUnit) { 4116 ASTUnit *TU = getCursorASTUnit(C); 4117 FileID MainID = TU->getSourceManager().getMainFileID(); 4118 SourceLocation Start = TU->getSourceManager().getLocForStartOfFile(MainID); 4119 SourceLocation End = TU->getSourceManager().getLocForEndOfFile(MainID); 4120 return SourceRange(Start, End); 4121 } 4122 4123 if (C.kind >= CXCursor_FirstDecl && C.kind <= CXCursor_LastDecl) { 4124 Decl *D = cxcursor::getCursorDecl(C); 4125 if (!D) 4126 return SourceRange(); 4127 4128 SourceRange R = D->getSourceRange(); 4129 // FIXME: Multiple variables declared in a single declaration 4130 // currently lack the information needed to correctly determine their 4131 // ranges when accounting for the type-specifier. We use context 4132 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 4133 // and if so, whether it is the first decl. 4134 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 4135 if (!cxcursor::isFirstInDeclGroup(C)) 4136 R.setBegin(VD->getLocation()); 4137 } 4138 return R; 4139 } 4140 return SourceRange(); 4141} 4142 4143/// \brief Retrieves the "raw" cursor extent, which is then extended to include 4144/// the decl-specifier-seq for declarations. 4145static SourceRange getFullCursorExtent(CXCursor C, SourceManager &SrcMgr) { 4146 if (C.kind >= CXCursor_FirstDecl && C.kind <= CXCursor_LastDecl) { 4147 Decl *D = cxcursor::getCursorDecl(C); 4148 if (!D) 4149 return SourceRange(); 4150 4151 SourceRange R = D->getSourceRange(); 4152 4153 // Adjust the start of the location for declarations preceded by 4154 // declaration specifiers. 4155 SourceLocation StartLoc; 4156 if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) { 4157 if (TypeSourceInfo *TI = DD->getTypeSourceInfo()) 4158 StartLoc = TI->getTypeLoc().getLocStart(); 4159 } else if (TypedefDecl *Typedef = dyn_cast<TypedefDecl>(D)) { 4160 if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo()) 4161 StartLoc = TI->getTypeLoc().getLocStart(); 4162 } 4163 4164 if (StartLoc.isValid() && R.getBegin().isValid() && 4165 SrcMgr.isBeforeInTranslationUnit(StartLoc, R.getBegin())) 4166 R.setBegin(StartLoc); 4167 4168 // FIXME: Multiple variables declared in a single declaration 4169 // currently lack the information needed to correctly determine their 4170 // ranges when accounting for the type-specifier. We use context 4171 // stored in the CXCursor to determine if the VarDecl is in a DeclGroup, 4172 // and if so, whether it is the first decl. 4173 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 4174 if (!cxcursor::isFirstInDeclGroup(C)) 4175 R.setBegin(VD->getLocation()); 4176 } 4177 4178 return R; 4179 } 4180 4181 return getRawCursorExtent(C); 4182} 4183 4184extern "C" { 4185 4186CXSourceRange clang_getCursorExtent(CXCursor C) { 4187 SourceRange R = getRawCursorExtent(C); 4188 if (R.isInvalid()) 4189 return clang_getNullRange(); 4190 4191 return cxloc::translateSourceRange(getCursorContext(C), R); 4192} 4193 4194CXCursor clang_getCursorReferenced(CXCursor C) { 4195 if (clang_isInvalid(C.kind)) 4196 return clang_getNullCursor(); 4197 4198 CXTranslationUnit tu = getCursorTU(C); 4199 if (clang_isDeclaration(C.kind)) { 4200 Decl *D = getCursorDecl(C); 4201 if (!D) 4202 return clang_getNullCursor(); 4203 if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) 4204 return MakeCursorOverloadedDeclRef(Using, D->getLocation(), tu); 4205 if (ObjCPropertyImplDecl *PropImpl =dyn_cast<ObjCPropertyImplDecl>(D)) 4206 if (ObjCPropertyDecl *Property = PropImpl->getPropertyDecl()) 4207 return MakeCXCursor(Property, tu); 4208 4209 return C; 4210 } 4211 4212 if (clang_isExpression(C.kind)) { 4213 Expr *E = getCursorExpr(C); 4214 Decl *D = getDeclFromExpr(E); 4215 if (D) { 4216 CXCursor declCursor = MakeCXCursor(D, tu); 4217 declCursor = getSelectorIdentifierCursor(getSelectorIdentifierIndex(C), 4218 declCursor); 4219 return declCursor; 4220 } 4221 4222 if (OverloadExpr *Ovl = dyn_cast_or_null<OverloadExpr>(E)) 4223 return MakeCursorOverloadedDeclRef(Ovl, tu); 4224 4225 return clang_getNullCursor(); 4226 } 4227 4228 if (clang_isStatement(C.kind)) { 4229 Stmt *S = getCursorStmt(C); 4230 if (GotoStmt *Goto = dyn_cast_or_null<GotoStmt>(S)) 4231 if (LabelDecl *label = Goto->getLabel()) 4232 if (LabelStmt *labelS = label->getStmt()) 4233 return MakeCXCursor(labelS, getCursorDecl(C), tu); 4234 4235 return clang_getNullCursor(); 4236 } 4237 4238 if (C.kind == CXCursor_MacroExpansion) { 4239 if (MacroDefinition *Def = getCursorMacroExpansion(C)->getDefinition()) 4240 return MakeMacroDefinitionCursor(Def, tu); 4241 } 4242 4243 if (!clang_isReference(C.kind)) 4244 return clang_getNullCursor(); 4245 4246 switch (C.kind) { 4247 case CXCursor_ObjCSuperClassRef: 4248 return MakeCXCursor(getCursorObjCSuperClassRef(C).first, tu); 4249 4250 case CXCursor_ObjCProtocolRef: { 4251 ObjCProtocolDecl *Prot = getCursorObjCProtocolRef(C).first; 4252 if (ObjCProtocolDecl *Def = Prot->getDefinition()) 4253 return MakeCXCursor(Def, tu); 4254 4255 return MakeCXCursor(Prot, tu); 4256 } 4257 4258 case CXCursor_ObjCClassRef: { 4259 ObjCInterfaceDecl *Class = getCursorObjCClassRef(C).first; 4260 if (ObjCInterfaceDecl *Def = Class->getDefinition()) 4261 return MakeCXCursor(Def, tu); 4262 4263 return MakeCXCursor(Class, tu); 4264 } 4265 4266 case CXCursor_TypeRef: 4267 return MakeCXCursor(getCursorTypeRef(C).first, tu ); 4268 4269 case CXCursor_TemplateRef: 4270 return MakeCXCursor(getCursorTemplateRef(C).first, tu ); 4271 4272 case CXCursor_NamespaceRef: 4273 return MakeCXCursor(getCursorNamespaceRef(C).first, tu ); 4274 4275 case CXCursor_MemberRef: 4276 return MakeCXCursor(getCursorMemberRef(C).first, tu ); 4277 4278 case CXCursor_CXXBaseSpecifier: { 4279 CXXBaseSpecifier *B = cxcursor::getCursorCXXBaseSpecifier(C); 4280 return clang_getTypeDeclaration(cxtype::MakeCXType(B->getType(), 4281 tu )); 4282 } 4283 4284 case CXCursor_LabelRef: 4285 // FIXME: We end up faking the "parent" declaration here because we 4286 // don't want to make CXCursor larger. 4287 return MakeCXCursor(getCursorLabelRef(C).first, 4288 static_cast<ASTUnit*>(tu->TUData)->getASTContext() 4289 .getTranslationUnitDecl(), 4290 tu); 4291 4292 case CXCursor_OverloadedDeclRef: 4293 return C; 4294 4295 case CXCursor_VariableRef: 4296 return MakeCXCursor(getCursorVariableRef(C).first, tu); 4297 4298 default: 4299 // We would prefer to enumerate all non-reference cursor kinds here. 4300 llvm_unreachable("Unhandled reference cursor kind"); 4301 } 4302} 4303 4304CXCursor clang_getCursorDefinition(CXCursor C) { 4305 if (clang_isInvalid(C.kind)) 4306 return clang_getNullCursor(); 4307 4308 CXTranslationUnit TU = getCursorTU(C); 4309 4310 bool WasReference = false; 4311 if (clang_isReference(C.kind) || clang_isExpression(C.kind)) { 4312 C = clang_getCursorReferenced(C); 4313 WasReference = true; 4314 } 4315 4316 if (C.kind == CXCursor_MacroExpansion) 4317 return clang_getCursorReferenced(C); 4318 4319 if (!clang_isDeclaration(C.kind)) 4320 return clang_getNullCursor(); 4321 4322 Decl *D = getCursorDecl(C); 4323 if (!D) 4324 return clang_getNullCursor(); 4325 4326 switch (D->getKind()) { 4327 // Declaration kinds that don't really separate the notions of 4328 // declaration and definition. 4329 case Decl::Namespace: 4330 case Decl::Typedef: 4331 case Decl::TypeAlias: 4332 case Decl::TypeAliasTemplate: 4333 case Decl::TemplateTypeParm: 4334 case Decl::EnumConstant: 4335 case Decl::Field: 4336 case Decl::IndirectField: 4337 case Decl::ObjCIvar: 4338 case Decl::ObjCAtDefsField: 4339 case Decl::ImplicitParam: 4340 case Decl::ParmVar: 4341 case Decl::NonTypeTemplateParm: 4342 case Decl::TemplateTemplateParm: 4343 case Decl::ObjCCategoryImpl: 4344 case Decl::ObjCImplementation: 4345 case Decl::AccessSpec: 4346 case Decl::LinkageSpec: 4347 case Decl::ObjCPropertyImpl: 4348 case Decl::FileScopeAsm: 4349 case Decl::StaticAssert: 4350 case Decl::Block: 4351 case Decl::Label: // FIXME: Is this right?? 4352 case Decl::ClassScopeFunctionSpecialization: 4353 case Decl::Import: 4354 return C; 4355 4356 // Declaration kinds that don't make any sense here, but are 4357 // nonetheless harmless. 4358 case Decl::TranslationUnit: 4359 break; 4360 4361 // Declaration kinds for which the definition is not resolvable. 4362 case Decl::UnresolvedUsingTypename: 4363 case Decl::UnresolvedUsingValue: 4364 break; 4365 4366 case Decl::UsingDirective: 4367 return MakeCXCursor(cast<UsingDirectiveDecl>(D)->getNominatedNamespace(), 4368 TU); 4369 4370 case Decl::NamespaceAlias: 4371 return MakeCXCursor(cast<NamespaceAliasDecl>(D)->getNamespace(), TU); 4372 4373 case Decl::Enum: 4374 case Decl::Record: 4375 case Decl::CXXRecord: 4376 case Decl::ClassTemplateSpecialization: 4377 case Decl::ClassTemplatePartialSpecialization: 4378 if (TagDecl *Def = cast<TagDecl>(D)->getDefinition()) 4379 return MakeCXCursor(Def, TU); 4380 return clang_getNullCursor(); 4381 4382 case Decl::Function: 4383 case Decl::CXXMethod: 4384 case Decl::CXXConstructor: 4385 case Decl::CXXDestructor: 4386 case Decl::CXXConversion: { 4387 const FunctionDecl *Def = 0; 4388 if (cast<FunctionDecl>(D)->getBody(Def)) 4389 return MakeCXCursor(const_cast<FunctionDecl *>(Def), TU); 4390 return clang_getNullCursor(); 4391 } 4392 4393 case Decl::Var: { 4394 // Ask the variable if it has a definition. 4395 if (VarDecl *Def = cast<VarDecl>(D)->getDefinition()) 4396 return MakeCXCursor(Def, TU); 4397 return clang_getNullCursor(); 4398 } 4399 4400 case Decl::FunctionTemplate: { 4401 const FunctionDecl *Def = 0; 4402 if (cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->getBody(Def)) 4403 return MakeCXCursor(Def->getDescribedFunctionTemplate(), TU); 4404 return clang_getNullCursor(); 4405 } 4406 4407 case Decl::ClassTemplate: { 4408 if (RecordDecl *Def = cast<ClassTemplateDecl>(D)->getTemplatedDecl() 4409 ->getDefinition()) 4410 return MakeCXCursor(cast<CXXRecordDecl>(Def)->getDescribedClassTemplate(), 4411 TU); 4412 return clang_getNullCursor(); 4413 } 4414 4415 case Decl::Using: 4416 return MakeCursorOverloadedDeclRef(cast<UsingDecl>(D), 4417 D->getLocation(), TU); 4418 4419 case Decl::UsingShadow: 4420 return clang_getCursorDefinition( 4421 MakeCXCursor(cast<UsingShadowDecl>(D)->getTargetDecl(), 4422 TU)); 4423 4424 case Decl::ObjCMethod: { 4425 ObjCMethodDecl *Method = cast<ObjCMethodDecl>(D); 4426 if (Method->isThisDeclarationADefinition()) 4427 return C; 4428 4429 // Dig out the method definition in the associated 4430 // @implementation, if we have it. 4431 // FIXME: The ASTs should make finding the definition easier. 4432 if (ObjCInterfaceDecl *Class 4433 = dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) 4434 if (ObjCImplementationDecl *ClassImpl = Class->getImplementation()) 4435 if (ObjCMethodDecl *Def = ClassImpl->getMethod(Method->getSelector(), 4436 Method->isInstanceMethod())) 4437 if (Def->isThisDeclarationADefinition()) 4438 return MakeCXCursor(Def, TU); 4439 4440 return clang_getNullCursor(); 4441 } 4442 4443 case Decl::ObjCCategory: 4444 if (ObjCCategoryImplDecl *Impl 4445 = cast<ObjCCategoryDecl>(D)->getImplementation()) 4446 return MakeCXCursor(Impl, TU); 4447 return clang_getNullCursor(); 4448 4449 case Decl::ObjCProtocol: 4450 if (ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(D)->getDefinition()) 4451 return MakeCXCursor(Def, TU); 4452 return clang_getNullCursor(); 4453 4454 case Decl::ObjCInterface: { 4455 // There are two notions of a "definition" for an Objective-C 4456 // class: the interface and its implementation. When we resolved a 4457 // reference to an Objective-C class, produce the @interface as 4458 // the definition; when we were provided with the interface, 4459 // produce the @implementation as the definition. 4460 ObjCInterfaceDecl *IFace = cast<ObjCInterfaceDecl>(D); 4461 if (WasReference) { 4462 if (ObjCInterfaceDecl *Def = IFace->getDefinition()) 4463 return MakeCXCursor(Def, TU); 4464 } else if (ObjCImplementationDecl *Impl = IFace->getImplementation()) 4465 return MakeCXCursor(Impl, TU); 4466 return clang_getNullCursor(); 4467 } 4468 4469 case Decl::ObjCProperty: 4470 // FIXME: We don't really know where to find the 4471 // ObjCPropertyImplDecls that implement this property. 4472 return clang_getNullCursor(); 4473 4474 case Decl::ObjCCompatibleAlias: 4475 if (ObjCInterfaceDecl *Class 4476 = cast<ObjCCompatibleAliasDecl>(D)->getClassInterface()) 4477 if (ObjCInterfaceDecl *Def = Class->getDefinition()) 4478 return MakeCXCursor(Def, TU); 4479 4480 return clang_getNullCursor(); 4481 4482 case Decl::Friend: 4483 if (NamedDecl *Friend = cast<FriendDecl>(D)->getFriendDecl()) 4484 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 4485 return clang_getNullCursor(); 4486 4487 case Decl::FriendTemplate: 4488 if (NamedDecl *Friend = cast<FriendTemplateDecl>(D)->getFriendDecl()) 4489 return clang_getCursorDefinition(MakeCXCursor(Friend, TU)); 4490 return clang_getNullCursor(); 4491 } 4492 4493 return clang_getNullCursor(); 4494} 4495 4496unsigned clang_isCursorDefinition(CXCursor C) { 4497 if (!clang_isDeclaration(C.kind)) 4498 return 0; 4499 4500 return clang_getCursorDefinition(C) == C; 4501} 4502 4503CXCursor clang_getCanonicalCursor(CXCursor C) { 4504 if (!clang_isDeclaration(C.kind)) 4505 return C; 4506 4507 if (Decl *D = getCursorDecl(C)) { 4508 if (ObjCCategoryImplDecl *CatImplD = dyn_cast<ObjCCategoryImplDecl>(D)) 4509 if (ObjCCategoryDecl *CatD = CatImplD->getCategoryDecl()) 4510 return MakeCXCursor(CatD, getCursorTU(C)); 4511 4512 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 4513 if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) 4514 return MakeCXCursor(IFD, getCursorTU(C)); 4515 4516 return MakeCXCursor(D->getCanonicalDecl(), getCursorTU(C)); 4517 } 4518 4519 return C; 4520} 4521 4522int clang_Cursor_getObjCSelectorIndex(CXCursor cursor) { 4523 return cxcursor::getSelectorIdentifierIndexAndLoc(cursor).first; 4524} 4525 4526unsigned clang_getNumOverloadedDecls(CXCursor C) { 4527 if (C.kind != CXCursor_OverloadedDeclRef) 4528 return 0; 4529 4530 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(C).first; 4531 if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>()) 4532 return E->getNumDecls(); 4533 4534 if (OverloadedTemplateStorage *S 4535 = Storage.dyn_cast<OverloadedTemplateStorage*>()) 4536 return S->size(); 4537 4538 Decl *D = Storage.get<Decl*>(); 4539 if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) 4540 return Using->shadow_size(); 4541 4542 return 0; 4543} 4544 4545CXCursor clang_getOverloadedDecl(CXCursor cursor, unsigned index) { 4546 if (cursor.kind != CXCursor_OverloadedDeclRef) 4547 return clang_getNullCursor(); 4548 4549 if (index >= clang_getNumOverloadedDecls(cursor)) 4550 return clang_getNullCursor(); 4551 4552 CXTranslationUnit TU = getCursorTU(cursor); 4553 OverloadedDeclRefStorage Storage = getCursorOverloadedDeclRef(cursor).first; 4554 if (OverloadExpr *E = Storage.dyn_cast<OverloadExpr *>()) 4555 return MakeCXCursor(E->decls_begin()[index], TU); 4556 4557 if (OverloadedTemplateStorage *S 4558 = Storage.dyn_cast<OverloadedTemplateStorage*>()) 4559 return MakeCXCursor(S->begin()[index], TU); 4560 4561 Decl *D = Storage.get<Decl*>(); 4562 if (UsingDecl *Using = dyn_cast<UsingDecl>(D)) { 4563 // FIXME: This is, unfortunately, linear time. 4564 UsingDecl::shadow_iterator Pos = Using->shadow_begin(); 4565 std::advance(Pos, index); 4566 return MakeCXCursor(cast<UsingShadowDecl>(*Pos)->getTargetDecl(), TU); 4567 } 4568 4569 return clang_getNullCursor(); 4570} 4571 4572void clang_getDefinitionSpellingAndExtent(CXCursor C, 4573 const char **startBuf, 4574 const char **endBuf, 4575 unsigned *startLine, 4576 unsigned *startColumn, 4577 unsigned *endLine, 4578 unsigned *endColumn) { 4579 assert(getCursorDecl(C) && "CXCursor has null decl"); 4580 NamedDecl *ND = static_cast<NamedDecl *>(getCursorDecl(C)); 4581 FunctionDecl *FD = dyn_cast<FunctionDecl>(ND); 4582 CompoundStmt *Body = dyn_cast<CompoundStmt>(FD->getBody()); 4583 4584 SourceManager &SM = FD->getASTContext().getSourceManager(); 4585 *startBuf = SM.getCharacterData(Body->getLBracLoc()); 4586 *endBuf = SM.getCharacterData(Body->getRBracLoc()); 4587 *startLine = SM.getSpellingLineNumber(Body->getLBracLoc()); 4588 *startColumn = SM.getSpellingColumnNumber(Body->getLBracLoc()); 4589 *endLine = SM.getSpellingLineNumber(Body->getRBracLoc()); 4590 *endColumn = SM.getSpellingColumnNumber(Body->getRBracLoc()); 4591} 4592 4593 4594CXSourceRange clang_getCursorReferenceNameRange(CXCursor C, unsigned NameFlags, 4595 unsigned PieceIndex) { 4596 RefNamePieces Pieces; 4597 4598 switch (C.kind) { 4599 case CXCursor_MemberRefExpr: 4600 if (MemberExpr *E = dyn_cast<MemberExpr>(getCursorExpr(C))) 4601 Pieces = buildPieces(NameFlags, true, E->getMemberNameInfo(), 4602 E->getQualifierLoc().getSourceRange()); 4603 break; 4604 4605 case CXCursor_DeclRefExpr: 4606 if (DeclRefExpr *E = dyn_cast<DeclRefExpr>(getCursorExpr(C))) 4607 Pieces = buildPieces(NameFlags, false, E->getNameInfo(), 4608 E->getQualifierLoc().getSourceRange(), 4609 E->getOptionalExplicitTemplateArgs()); 4610 break; 4611 4612 case CXCursor_CallExpr: 4613 if (CXXOperatorCallExpr *OCE = 4614 dyn_cast<CXXOperatorCallExpr>(getCursorExpr(C))) { 4615 Expr *Callee = OCE->getCallee(); 4616 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Callee)) 4617 Callee = ICE->getSubExpr(); 4618 4619 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Callee)) 4620 Pieces = buildPieces(NameFlags, false, DRE->getNameInfo(), 4621 DRE->getQualifierLoc().getSourceRange()); 4622 } 4623 break; 4624 4625 default: 4626 break; 4627 } 4628 4629 if (Pieces.empty()) { 4630 if (PieceIndex == 0) 4631 return clang_getCursorExtent(C); 4632 } else if (PieceIndex < Pieces.size()) { 4633 SourceRange R = Pieces[PieceIndex]; 4634 if (R.isValid()) 4635 return cxloc::translateSourceRange(getCursorContext(C), R); 4636 } 4637 4638 return clang_getNullRange(); 4639} 4640 4641void clang_enableStackTraces(void) { 4642 llvm::sys::PrintStackTraceOnErrorSignal(); 4643} 4644 4645void clang_executeOnThread(void (*fn)(void*), void *user_data, 4646 unsigned stack_size) { 4647 llvm::llvm_execute_on_thread(fn, user_data, stack_size); 4648} 4649 4650} // end: extern "C" 4651 4652//===----------------------------------------------------------------------===// 4653// Token-based Operations. 4654//===----------------------------------------------------------------------===// 4655 4656/* CXToken layout: 4657 * int_data[0]: a CXTokenKind 4658 * int_data[1]: starting token location 4659 * int_data[2]: token length 4660 * int_data[3]: reserved 4661 * ptr_data: for identifiers and keywords, an IdentifierInfo*. 4662 * otherwise unused. 4663 */ 4664extern "C" { 4665 4666CXTokenKind clang_getTokenKind(CXToken CXTok) { 4667 return static_cast<CXTokenKind>(CXTok.int_data[0]); 4668} 4669 4670CXString clang_getTokenSpelling(CXTranslationUnit TU, CXToken CXTok) { 4671 switch (clang_getTokenKind(CXTok)) { 4672 case CXToken_Identifier: 4673 case CXToken_Keyword: 4674 // We know we have an IdentifierInfo*, so use that. 4675 return createCXString(static_cast<IdentifierInfo *>(CXTok.ptr_data) 4676 ->getNameStart()); 4677 4678 case CXToken_Literal: { 4679 // We have stashed the starting pointer in the ptr_data field. Use it. 4680 const char *Text = static_cast<const char *>(CXTok.ptr_data); 4681 return createCXString(StringRef(Text, CXTok.int_data[2])); 4682 } 4683 4684 case CXToken_Punctuation: 4685 case CXToken_Comment: 4686 break; 4687 } 4688 4689 // We have to find the starting buffer pointer the hard way, by 4690 // deconstructing the source location. 4691 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4692 if (!CXXUnit) 4693 return createCXString(""); 4694 4695 SourceLocation Loc = SourceLocation::getFromRawEncoding(CXTok.int_data[1]); 4696 std::pair<FileID, unsigned> LocInfo 4697 = CXXUnit->getSourceManager().getDecomposedSpellingLoc(Loc); 4698 bool Invalid = false; 4699 StringRef Buffer 4700 = CXXUnit->getSourceManager().getBufferData(LocInfo.first, &Invalid); 4701 if (Invalid) 4702 return createCXString(""); 4703 4704 return createCXString(Buffer.substr(LocInfo.second, CXTok.int_data[2])); 4705} 4706 4707CXSourceLocation clang_getTokenLocation(CXTranslationUnit TU, CXToken CXTok) { 4708 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4709 if (!CXXUnit) 4710 return clang_getNullLocation(); 4711 4712 return cxloc::translateSourceLocation(CXXUnit->getASTContext(), 4713 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 4714} 4715 4716CXSourceRange clang_getTokenExtent(CXTranslationUnit TU, CXToken CXTok) { 4717 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4718 if (!CXXUnit) 4719 return clang_getNullRange(); 4720 4721 return cxloc::translateSourceRange(CXXUnit->getASTContext(), 4722 SourceLocation::getFromRawEncoding(CXTok.int_data[1])); 4723} 4724 4725static void getTokens(ASTUnit *CXXUnit, SourceRange Range, 4726 SmallVectorImpl<CXToken> &CXTokens) { 4727 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 4728 std::pair<FileID, unsigned> BeginLocInfo 4729 = SourceMgr.getDecomposedLoc(Range.getBegin()); 4730 std::pair<FileID, unsigned> EndLocInfo 4731 = SourceMgr.getDecomposedLoc(Range.getEnd()); 4732 4733 // Cannot tokenize across files. 4734 if (BeginLocInfo.first != EndLocInfo.first) 4735 return; 4736 4737 // Create a lexer 4738 bool Invalid = false; 4739 StringRef Buffer 4740 = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid); 4741 if (Invalid) 4742 return; 4743 4744 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 4745 CXXUnit->getASTContext().getLangOpts(), 4746 Buffer.begin(), Buffer.data() + BeginLocInfo.second, Buffer.end()); 4747 Lex.SetCommentRetentionState(true); 4748 4749 // Lex tokens until we hit the end of the range. 4750 const char *EffectiveBufferEnd = Buffer.data() + EndLocInfo.second; 4751 Token Tok; 4752 bool previousWasAt = false; 4753 do { 4754 // Lex the next token 4755 Lex.LexFromRawLexer(Tok); 4756 if (Tok.is(tok::eof)) 4757 break; 4758 4759 // Initialize the CXToken. 4760 CXToken CXTok; 4761 4762 // - Common fields 4763 CXTok.int_data[1] = Tok.getLocation().getRawEncoding(); 4764 CXTok.int_data[2] = Tok.getLength(); 4765 CXTok.int_data[3] = 0; 4766 4767 // - Kind-specific fields 4768 if (Tok.isLiteral()) { 4769 CXTok.int_data[0] = CXToken_Literal; 4770 CXTok.ptr_data = (void *)Tok.getLiteralData(); 4771 } else if (Tok.is(tok::raw_identifier)) { 4772 // Lookup the identifier to determine whether we have a keyword. 4773 IdentifierInfo *II 4774 = CXXUnit->getPreprocessor().LookUpIdentifierInfo(Tok); 4775 4776 if ((II->getObjCKeywordID() != tok::objc_not_keyword) && previousWasAt) { 4777 CXTok.int_data[0] = CXToken_Keyword; 4778 } 4779 else { 4780 CXTok.int_data[0] = Tok.is(tok::identifier) 4781 ? CXToken_Identifier 4782 : CXToken_Keyword; 4783 } 4784 CXTok.ptr_data = II; 4785 } else if (Tok.is(tok::comment)) { 4786 CXTok.int_data[0] = CXToken_Comment; 4787 CXTok.ptr_data = 0; 4788 } else { 4789 CXTok.int_data[0] = CXToken_Punctuation; 4790 CXTok.ptr_data = 0; 4791 } 4792 CXTokens.push_back(CXTok); 4793 previousWasAt = Tok.is(tok::at); 4794 } while (Lex.getBufferLocation() <= EffectiveBufferEnd); 4795} 4796 4797void clang_tokenize(CXTranslationUnit TU, CXSourceRange Range, 4798 CXToken **Tokens, unsigned *NumTokens) { 4799 if (Tokens) 4800 *Tokens = 0; 4801 if (NumTokens) 4802 *NumTokens = 0; 4803 4804 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 4805 if (!CXXUnit || !Tokens || !NumTokens) 4806 return; 4807 4808 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 4809 4810 SourceRange R = cxloc::translateCXSourceRange(Range); 4811 if (R.isInvalid()) 4812 return; 4813 4814 SmallVector<CXToken, 32> CXTokens; 4815 getTokens(CXXUnit, R, CXTokens); 4816 4817 if (CXTokens.empty()) 4818 return; 4819 4820 *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size()); 4821 memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size()); 4822 *NumTokens = CXTokens.size(); 4823} 4824 4825void clang_disposeTokens(CXTranslationUnit TU, 4826 CXToken *Tokens, unsigned NumTokens) { 4827 free(Tokens); 4828} 4829 4830} // end: extern "C" 4831 4832//===----------------------------------------------------------------------===// 4833// Token annotation APIs. 4834//===----------------------------------------------------------------------===// 4835 4836typedef llvm::DenseMap<unsigned, CXCursor> AnnotateTokensData; 4837static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 4838 CXCursor parent, 4839 CXClientData client_data); 4840static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor, 4841 CXClientData client_data); 4842 4843namespace { 4844class AnnotateTokensWorker { 4845 AnnotateTokensData &Annotated; 4846 CXToken *Tokens; 4847 CXCursor *Cursors; 4848 unsigned NumTokens; 4849 unsigned TokIdx; 4850 unsigned PreprocessingTokIdx; 4851 CursorVisitor AnnotateVis; 4852 SourceManager &SrcMgr; 4853 bool HasContextSensitiveKeywords; 4854 4855 struct PostChildrenInfo { 4856 CXCursor Cursor; 4857 SourceRange CursorRange; 4858 unsigned BeforeChildrenTokenIdx; 4859 }; 4860 llvm::SmallVector<PostChildrenInfo, 8> PostChildrenInfos; 4861 4862 bool MoreTokens() const { return TokIdx < NumTokens; } 4863 unsigned NextToken() const { return TokIdx; } 4864 void AdvanceToken() { ++TokIdx; } 4865 SourceLocation GetTokenLoc(unsigned tokI) { 4866 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]); 4867 } 4868 bool isFunctionMacroToken(unsigned tokI) const { 4869 return Tokens[tokI].int_data[3] != 0; 4870 } 4871 SourceLocation getFunctionMacroTokenLoc(unsigned tokI) const { 4872 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[3]); 4873 } 4874 4875 void annotateAndAdvanceTokens(CXCursor, RangeComparisonResult, SourceRange); 4876 void annotateAndAdvanceFunctionMacroTokens(CXCursor, RangeComparisonResult, 4877 SourceRange); 4878 4879public: 4880 AnnotateTokensWorker(AnnotateTokensData &annotated, 4881 CXToken *tokens, CXCursor *cursors, unsigned numTokens, 4882 CXTranslationUnit tu, SourceRange RegionOfInterest) 4883 : Annotated(annotated), Tokens(tokens), Cursors(cursors), 4884 NumTokens(numTokens), TokIdx(0), PreprocessingTokIdx(0), 4885 AnnotateVis(tu, 4886 AnnotateTokensVisitor, this, 4887 /*VisitPreprocessorLast=*/true, 4888 /*VisitIncludedEntities=*/false, 4889 RegionOfInterest, 4890 /*VisitDeclsOnly=*/false, 4891 AnnotateTokensPostChildrenVisitor), 4892 SrcMgr(static_cast<ASTUnit*>(tu->TUData)->getSourceManager()), 4893 HasContextSensitiveKeywords(false) { } 4894 4895 void VisitChildren(CXCursor C) { AnnotateVis.VisitChildren(C); } 4896 enum CXChildVisitResult Visit(CXCursor cursor, CXCursor parent); 4897 bool postVisitChildren(CXCursor cursor); 4898 void AnnotateTokens(); 4899 4900 /// \brief Determine whether the annotator saw any cursors that have 4901 /// context-sensitive keywords. 4902 bool hasContextSensitiveKeywords() const { 4903 return HasContextSensitiveKeywords; 4904 } 4905 4906 ~AnnotateTokensWorker() { 4907 assert(PostChildrenInfos.empty()); 4908 } 4909}; 4910} 4911 4912void AnnotateTokensWorker::AnnotateTokens() { 4913 // Walk the AST within the region of interest, annotating tokens 4914 // along the way. 4915 AnnotateVis.visitFileRegion(); 4916 4917 for (unsigned I = 0 ; I < TokIdx ; ++I) { 4918 AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]); 4919 if (Pos != Annotated.end() && 4920 (clang_isInvalid(Cursors[I].kind) || 4921 Pos->second.kind != CXCursor_PreprocessingDirective)) 4922 Cursors[I] = Pos->second; 4923 } 4924 4925 // Finish up annotating any tokens left. 4926 if (!MoreTokens()) 4927 return; 4928 4929 const CXCursor &C = clang_getNullCursor(); 4930 for (unsigned I = TokIdx ; I < NumTokens ; ++I) { 4931 if (I < PreprocessingTokIdx && clang_isPreprocessing(Cursors[I].kind)) 4932 continue; 4933 4934 AnnotateTokensData::iterator Pos = Annotated.find(Tokens[I].int_data[1]); 4935 Cursors[I] = (Pos == Annotated.end()) ? C : Pos->second; 4936 } 4937} 4938 4939/// \brief It annotates and advances tokens with a cursor until the comparison 4940//// between the cursor location and the source range is the same as 4941/// \arg compResult. 4942/// 4943/// Pass RangeBefore to annotate tokens with a cursor until a range is reached. 4944/// Pass RangeOverlap to annotate tokens inside a range. 4945void AnnotateTokensWorker::annotateAndAdvanceTokens(CXCursor updateC, 4946 RangeComparisonResult compResult, 4947 SourceRange range) { 4948 while (MoreTokens()) { 4949 const unsigned I = NextToken(); 4950 if (isFunctionMacroToken(I)) 4951 return annotateAndAdvanceFunctionMacroTokens(updateC, compResult, range); 4952 4953 SourceLocation TokLoc = GetTokenLoc(I); 4954 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) { 4955 Cursors[I] = updateC; 4956 AdvanceToken(); 4957 continue; 4958 } 4959 break; 4960 } 4961} 4962 4963/// \brief Special annotation handling for macro argument tokens. 4964void AnnotateTokensWorker::annotateAndAdvanceFunctionMacroTokens( 4965 CXCursor updateC, 4966 RangeComparisonResult compResult, 4967 SourceRange range) { 4968 assert(MoreTokens()); 4969 assert(isFunctionMacroToken(NextToken()) && 4970 "Should be called only for macro arg tokens"); 4971 4972 // This works differently than annotateAndAdvanceTokens; because expanded 4973 // macro arguments can have arbitrary translation-unit source order, we do not 4974 // advance the token index one by one until a token fails the range test. 4975 // We only advance once past all of the macro arg tokens if all of them 4976 // pass the range test. If one of them fails we keep the token index pointing 4977 // at the start of the macro arg tokens so that the failing token will be 4978 // annotated by a subsequent annotation try. 4979 4980 bool atLeastOneCompFail = false; 4981 4982 unsigned I = NextToken(); 4983 for (; I < NumTokens && isFunctionMacroToken(I); ++I) { 4984 SourceLocation TokLoc = getFunctionMacroTokenLoc(I); 4985 if (TokLoc.isFileID()) 4986 continue; // not macro arg token, it's parens or comma. 4987 if (LocationCompare(SrcMgr, TokLoc, range) == compResult) { 4988 if (clang_isInvalid(clang_getCursorKind(Cursors[I]))) 4989 Cursors[I] = updateC; 4990 } else 4991 atLeastOneCompFail = true; 4992 } 4993 4994 if (!atLeastOneCompFail) 4995 TokIdx = I; // All of the tokens were handled, advance beyond all of them. 4996} 4997 4998enum CXChildVisitResult 4999AnnotateTokensWorker::Visit(CXCursor cursor, CXCursor parent) { 5000 CXSourceLocation Loc = clang_getCursorLocation(cursor); 5001 SourceRange cursorRange = getRawCursorExtent(cursor); 5002 if (cursorRange.isInvalid()) 5003 return CXChildVisit_Recurse; 5004 5005 if (!HasContextSensitiveKeywords) { 5006 // Objective-C properties can have context-sensitive keywords. 5007 if (cursor.kind == CXCursor_ObjCPropertyDecl) { 5008 if (ObjCPropertyDecl *Property 5009 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(cursor))) 5010 HasContextSensitiveKeywords = Property->getPropertyAttributesAsWritten() != 0; 5011 } 5012 // Objective-C methods can have context-sensitive keywords. 5013 else if (cursor.kind == CXCursor_ObjCInstanceMethodDecl || 5014 cursor.kind == CXCursor_ObjCClassMethodDecl) { 5015 if (ObjCMethodDecl *Method 5016 = dyn_cast_or_null<ObjCMethodDecl>(getCursorDecl(cursor))) { 5017 if (Method->getObjCDeclQualifier()) 5018 HasContextSensitiveKeywords = true; 5019 else { 5020 for (ObjCMethodDecl::param_iterator P = Method->param_begin(), 5021 PEnd = Method->param_end(); 5022 P != PEnd; ++P) { 5023 if ((*P)->getObjCDeclQualifier()) { 5024 HasContextSensitiveKeywords = true; 5025 break; 5026 } 5027 } 5028 } 5029 } 5030 } 5031 // C++ methods can have context-sensitive keywords. 5032 else if (cursor.kind == CXCursor_CXXMethod) { 5033 if (CXXMethodDecl *Method 5034 = dyn_cast_or_null<CXXMethodDecl>(getCursorDecl(cursor))) { 5035 if (Method->hasAttr<FinalAttr>() || Method->hasAttr<OverrideAttr>()) 5036 HasContextSensitiveKeywords = true; 5037 } 5038 } 5039 // C++ classes can have context-sensitive keywords. 5040 else if (cursor.kind == CXCursor_StructDecl || 5041 cursor.kind == CXCursor_ClassDecl || 5042 cursor.kind == CXCursor_ClassTemplate || 5043 cursor.kind == CXCursor_ClassTemplatePartialSpecialization) { 5044 if (Decl *D = getCursorDecl(cursor)) 5045 if (D->hasAttr<FinalAttr>()) 5046 HasContextSensitiveKeywords = true; 5047 } 5048 } 5049 5050 if (clang_isPreprocessing(cursor.kind)) { 5051 // For macro expansions, just note where the beginning of the macro 5052 // expansion occurs. 5053 if (cursor.kind == CXCursor_MacroExpansion) { 5054 Annotated[Loc.int_data] = cursor; 5055 return CXChildVisit_Recurse; 5056 } 5057 5058 // Items in the preprocessing record are kept separate from items in 5059 // declarations, so we keep a separate token index. 5060 unsigned SavedTokIdx = TokIdx; 5061 TokIdx = PreprocessingTokIdx; 5062 5063 // Skip tokens up until we catch up to the beginning of the preprocessing 5064 // entry. 5065 while (MoreTokens()) { 5066 const unsigned I = NextToken(); 5067 SourceLocation TokLoc = GetTokenLoc(I); 5068 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 5069 case RangeBefore: 5070 AdvanceToken(); 5071 continue; 5072 case RangeAfter: 5073 case RangeOverlap: 5074 break; 5075 } 5076 break; 5077 } 5078 5079 // Look at all of the tokens within this range. 5080 while (MoreTokens()) { 5081 const unsigned I = NextToken(); 5082 SourceLocation TokLoc = GetTokenLoc(I); 5083 switch (LocationCompare(SrcMgr, TokLoc, cursorRange)) { 5084 case RangeBefore: 5085 llvm_unreachable("Infeasible"); 5086 case RangeAfter: 5087 break; 5088 case RangeOverlap: 5089 Cursors[I] = cursor; 5090 AdvanceToken(); 5091 continue; 5092 } 5093 break; 5094 } 5095 5096 // Save the preprocessing token index; restore the non-preprocessing 5097 // token index. 5098 PreprocessingTokIdx = TokIdx; 5099 TokIdx = SavedTokIdx; 5100 return CXChildVisit_Recurse; 5101 } 5102 5103 if (cursorRange.isInvalid()) 5104 return CXChildVisit_Continue; 5105 5106 SourceLocation L = SourceLocation::getFromRawEncoding(Loc.int_data); 5107 5108 // Adjust the annotated range based specific declarations. 5109 const enum CXCursorKind cursorK = clang_getCursorKind(cursor); 5110 if (cursorK >= CXCursor_FirstDecl && cursorK <= CXCursor_LastDecl) { 5111 Decl *D = cxcursor::getCursorDecl(cursor); 5112 5113 SourceLocation StartLoc; 5114 if (const DeclaratorDecl *DD = dyn_cast_or_null<DeclaratorDecl>(D)) { 5115 if (TypeSourceInfo *TI = DD->getTypeSourceInfo()) 5116 StartLoc = TI->getTypeLoc().getLocStart(); 5117 } else if (TypedefDecl *Typedef = dyn_cast_or_null<TypedefDecl>(D)) { 5118 if (TypeSourceInfo *TI = Typedef->getTypeSourceInfo()) 5119 StartLoc = TI->getTypeLoc().getLocStart(); 5120 } 5121 5122 if (StartLoc.isValid() && L.isValid() && 5123 SrcMgr.isBeforeInTranslationUnit(StartLoc, L)) 5124 cursorRange.setBegin(StartLoc); 5125 } 5126 5127 // If the location of the cursor occurs within a macro instantiation, record 5128 // the spelling location of the cursor in our annotation map. We can then 5129 // paper over the token labelings during a post-processing step to try and 5130 // get cursor mappings for tokens that are the *arguments* of a macro 5131 // instantiation. 5132 if (L.isMacroID()) { 5133 unsigned rawEncoding = SrcMgr.getSpellingLoc(L).getRawEncoding(); 5134 // Only invalidate the old annotation if it isn't part of a preprocessing 5135 // directive. Here we assume that the default construction of CXCursor 5136 // results in CXCursor.kind being an initialized value (i.e., 0). If 5137 // this isn't the case, we can fix by doing lookup + insertion. 5138 5139 CXCursor &oldC = Annotated[rawEncoding]; 5140 if (!clang_isPreprocessing(oldC.kind)) 5141 oldC = cursor; 5142 } 5143 5144 const enum CXCursorKind K = clang_getCursorKind(parent); 5145 const CXCursor updateC = 5146 (clang_isInvalid(K) || K == CXCursor_TranslationUnit) 5147 ? clang_getNullCursor() : parent; 5148 5149 annotateAndAdvanceTokens(updateC, RangeBefore, cursorRange); 5150 5151 // Avoid having the cursor of an expression "overwrite" the annotation of the 5152 // variable declaration that it belongs to. 5153 // This can happen for C++ constructor expressions whose range generally 5154 // include the variable declaration, e.g.: 5155 // MyCXXClass foo; // Make sure we don't annotate 'foo' as a CallExpr cursor. 5156 if (clang_isExpression(cursorK)) { 5157 Expr *E = getCursorExpr(cursor); 5158 if (Decl *D = getCursorParentDecl(cursor)) { 5159 const unsigned I = NextToken(); 5160 if (E->getLocStart().isValid() && D->getLocation().isValid() && 5161 E->getLocStart() == D->getLocation() && 5162 E->getLocStart() == GetTokenLoc(I)) { 5163 Cursors[I] = updateC; 5164 AdvanceToken(); 5165 } 5166 } 5167 } 5168 5169 // Before recursing into the children keep some state that we are going 5170 // to use in the AnnotateTokensWorker::postVisitChildren callback to do some 5171 // extra work after the child nodes are visited. 5172 // Note that we don't call VisitChildren here to avoid traversing statements 5173 // code-recursively which can blow the stack. 5174 5175 PostChildrenInfo Info; 5176 Info.Cursor = cursor; 5177 Info.CursorRange = cursorRange; 5178 Info.BeforeChildrenTokenIdx = NextToken(); 5179 PostChildrenInfos.push_back(Info); 5180 5181 return CXChildVisit_Recurse; 5182} 5183 5184bool AnnotateTokensWorker::postVisitChildren(CXCursor cursor) { 5185 if (PostChildrenInfos.empty()) 5186 return false; 5187 const PostChildrenInfo &Info = PostChildrenInfos.back(); 5188 if (!clang_equalCursors(Info.Cursor, cursor)) 5189 return false; 5190 5191 const unsigned BeforeChildren = Info.BeforeChildrenTokenIdx; 5192 const unsigned AfterChildren = NextToken(); 5193 SourceRange cursorRange = Info.CursorRange; 5194 5195 // Scan the tokens that are at the end of the cursor, but are not captured 5196 // but the child cursors. 5197 annotateAndAdvanceTokens(cursor, RangeOverlap, cursorRange); 5198 5199 // Scan the tokens that are at the beginning of the cursor, but are not 5200 // capture by the child cursors. 5201 for (unsigned I = BeforeChildren; I != AfterChildren; ++I) { 5202 if (!clang_isInvalid(clang_getCursorKind(Cursors[I]))) 5203 break; 5204 5205 Cursors[I] = cursor; 5206 } 5207 5208 PostChildrenInfos.pop_back(); 5209 return false; 5210} 5211 5212static enum CXChildVisitResult AnnotateTokensVisitor(CXCursor cursor, 5213 CXCursor parent, 5214 CXClientData client_data) { 5215 return static_cast<AnnotateTokensWorker*>(client_data)->Visit(cursor, parent); 5216} 5217 5218static bool AnnotateTokensPostChildrenVisitor(CXCursor cursor, 5219 CXClientData client_data) { 5220 return static_cast<AnnotateTokensWorker*>(client_data)-> 5221 postVisitChildren(cursor); 5222} 5223 5224namespace { 5225 5226/// \brief Uses the macro expansions in the preprocessing record to find 5227/// and mark tokens that are macro arguments. This info is used by the 5228/// AnnotateTokensWorker. 5229class MarkMacroArgTokensVisitor { 5230 SourceManager &SM; 5231 CXToken *Tokens; 5232 unsigned NumTokens; 5233 unsigned CurIdx; 5234 5235public: 5236 MarkMacroArgTokensVisitor(SourceManager &SM, 5237 CXToken *tokens, unsigned numTokens) 5238 : SM(SM), Tokens(tokens), NumTokens(numTokens), CurIdx(0) { } 5239 5240 CXChildVisitResult visit(CXCursor cursor, CXCursor parent) { 5241 if (cursor.kind != CXCursor_MacroExpansion) 5242 return CXChildVisit_Continue; 5243 5244 SourceRange macroRange = getCursorMacroExpansion(cursor)->getSourceRange(); 5245 if (macroRange.getBegin() == macroRange.getEnd()) 5246 return CXChildVisit_Continue; // it's not a function macro. 5247 5248 for (; CurIdx < NumTokens; ++CurIdx) { 5249 if (!SM.isBeforeInTranslationUnit(getTokenLoc(CurIdx), 5250 macroRange.getBegin())) 5251 break; 5252 } 5253 5254 if (CurIdx == NumTokens) 5255 return CXChildVisit_Break; 5256 5257 for (; CurIdx < NumTokens; ++CurIdx) { 5258 SourceLocation tokLoc = getTokenLoc(CurIdx); 5259 if (!SM.isBeforeInTranslationUnit(tokLoc, macroRange.getEnd())) 5260 break; 5261 5262 setFunctionMacroTokenLoc(CurIdx, SM.getMacroArgExpandedLocation(tokLoc)); 5263 } 5264 5265 if (CurIdx == NumTokens) 5266 return CXChildVisit_Break; 5267 5268 return CXChildVisit_Continue; 5269 } 5270 5271private: 5272 SourceLocation getTokenLoc(unsigned tokI) { 5273 return SourceLocation::getFromRawEncoding(Tokens[tokI].int_data[1]); 5274 } 5275 5276 void setFunctionMacroTokenLoc(unsigned tokI, SourceLocation loc) { 5277 // The third field is reserved and currently not used. Use it here 5278 // to mark macro arg expanded tokens with their expanded locations. 5279 Tokens[tokI].int_data[3] = loc.getRawEncoding(); 5280 } 5281}; 5282 5283} // end anonymous namespace 5284 5285static CXChildVisitResult 5286MarkMacroArgTokensVisitorDelegate(CXCursor cursor, CXCursor parent, 5287 CXClientData client_data) { 5288 return static_cast<MarkMacroArgTokensVisitor*>(client_data)->visit(cursor, 5289 parent); 5290} 5291 5292namespace { 5293 struct clang_annotateTokens_Data { 5294 CXTranslationUnit TU; 5295 ASTUnit *CXXUnit; 5296 CXToken *Tokens; 5297 unsigned NumTokens; 5298 CXCursor *Cursors; 5299 }; 5300} 5301 5302static void annotatePreprocessorTokens(CXTranslationUnit TU, 5303 SourceRange RegionOfInterest, 5304 AnnotateTokensData &Annotated) { 5305 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 5306 5307 SourceManager &SourceMgr = CXXUnit->getSourceManager(); 5308 std::pair<FileID, unsigned> BeginLocInfo 5309 = SourceMgr.getDecomposedLoc(RegionOfInterest.getBegin()); 5310 std::pair<FileID, unsigned> EndLocInfo 5311 = SourceMgr.getDecomposedLoc(RegionOfInterest.getEnd()); 5312 5313 if (BeginLocInfo.first != EndLocInfo.first) 5314 return; 5315 5316 StringRef Buffer; 5317 bool Invalid = false; 5318 Buffer = SourceMgr.getBufferData(BeginLocInfo.first, &Invalid); 5319 if (Buffer.empty() || Invalid) 5320 return; 5321 5322 Lexer Lex(SourceMgr.getLocForStartOfFile(BeginLocInfo.first), 5323 CXXUnit->getASTContext().getLangOpts(), 5324 Buffer.begin(), Buffer.data() + BeginLocInfo.second, 5325 Buffer.end()); 5326 Lex.SetCommentRetentionState(true); 5327 5328 // Lex tokens in raw mode until we hit the end of the range, to avoid 5329 // entering #includes or expanding macros. 5330 while (true) { 5331 Token Tok; 5332 Lex.LexFromRawLexer(Tok); 5333 5334 reprocess: 5335 if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) { 5336 // We have found a preprocessing directive. Gobble it up so that we 5337 // don't see it while preprocessing these tokens later, but keep track 5338 // of all of the token locations inside this preprocessing directive so 5339 // that we can annotate them appropriately. 5340 // 5341 // FIXME: Some simple tests here could identify macro definitions and 5342 // #undefs, to provide specific cursor kinds for those. 5343 SmallVector<SourceLocation, 32> Locations; 5344 do { 5345 Locations.push_back(Tok.getLocation()); 5346 Lex.LexFromRawLexer(Tok); 5347 } while (!Tok.isAtStartOfLine() && !Tok.is(tok::eof)); 5348 5349 using namespace cxcursor; 5350 CXCursor Cursor 5351 = MakePreprocessingDirectiveCursor(SourceRange(Locations.front(), 5352 Locations.back()), 5353 TU); 5354 for (unsigned I = 0, N = Locations.size(); I != N; ++I) { 5355 Annotated[Locations[I].getRawEncoding()] = Cursor; 5356 } 5357 5358 if (Tok.isAtStartOfLine()) 5359 goto reprocess; 5360 5361 continue; 5362 } 5363 5364 if (Tok.is(tok::eof)) 5365 break; 5366 } 5367} 5368 5369// This gets run a separate thread to avoid stack blowout. 5370static void clang_annotateTokensImpl(void *UserData) { 5371 CXTranslationUnit TU = ((clang_annotateTokens_Data*)UserData)->TU; 5372 ASTUnit *CXXUnit = ((clang_annotateTokens_Data*)UserData)->CXXUnit; 5373 CXToken *Tokens = ((clang_annotateTokens_Data*)UserData)->Tokens; 5374 const unsigned NumTokens = ((clang_annotateTokens_Data*)UserData)->NumTokens; 5375 CXCursor *Cursors = ((clang_annotateTokens_Data*)UserData)->Cursors; 5376 5377 CIndexer *CXXIdx = (CIndexer*)TU->CIdx; 5378 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 5379 setThreadBackgroundPriority(); 5380 5381 // Determine the region of interest, which contains all of the tokens. 5382 SourceRange RegionOfInterest; 5383 RegionOfInterest.setBegin( 5384 cxloc::translateSourceLocation(clang_getTokenLocation(TU, Tokens[0]))); 5385 RegionOfInterest.setEnd( 5386 cxloc::translateSourceLocation(clang_getTokenLocation(TU, 5387 Tokens[NumTokens-1]))); 5388 5389 // A mapping from the source locations found when re-lexing or traversing the 5390 // region of interest to the corresponding cursors. 5391 AnnotateTokensData Annotated; 5392 5393 // Relex the tokens within the source range to look for preprocessing 5394 // directives. 5395 annotatePreprocessorTokens(TU, RegionOfInterest, Annotated); 5396 5397 if (CXXUnit->getPreprocessor().getPreprocessingRecord()) { 5398 // Search and mark tokens that are macro argument expansions. 5399 MarkMacroArgTokensVisitor Visitor(CXXUnit->getSourceManager(), 5400 Tokens, NumTokens); 5401 CursorVisitor MacroArgMarker(TU, 5402 MarkMacroArgTokensVisitorDelegate, &Visitor, 5403 /*VisitPreprocessorLast=*/true, 5404 /*VisitIncludedEntities=*/false, 5405 RegionOfInterest); 5406 MacroArgMarker.visitPreprocessedEntitiesInRegion(); 5407 } 5408 5409 // Annotate all of the source locations in the region of interest that map to 5410 // a specific cursor. 5411 AnnotateTokensWorker W(Annotated, Tokens, Cursors, NumTokens, 5412 TU, RegionOfInterest); 5413 5414 // FIXME: We use a ridiculous stack size here because the data-recursion 5415 // algorithm uses a large stack frame than the non-data recursive version, 5416 // and AnnotationTokensWorker currently transforms the data-recursion 5417 // algorithm back into a traditional recursion by explicitly calling 5418 // VisitChildren(). We will need to remove this explicit recursive call. 5419 W.AnnotateTokens(); 5420 5421 // If we ran into any entities that involve context-sensitive keywords, 5422 // take another pass through the tokens to mark them as such. 5423 if (W.hasContextSensitiveKeywords()) { 5424 for (unsigned I = 0; I != NumTokens; ++I) { 5425 if (clang_getTokenKind(Tokens[I]) != CXToken_Identifier) 5426 continue; 5427 5428 if (Cursors[I].kind == CXCursor_ObjCPropertyDecl) { 5429 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 5430 if (ObjCPropertyDecl *Property 5431 = dyn_cast_or_null<ObjCPropertyDecl>(getCursorDecl(Cursors[I]))) { 5432 if (Property->getPropertyAttributesAsWritten() != 0 && 5433 llvm::StringSwitch<bool>(II->getName()) 5434 .Case("readonly", true) 5435 .Case("assign", true) 5436 .Case("unsafe_unretained", true) 5437 .Case("readwrite", true) 5438 .Case("retain", true) 5439 .Case("copy", true) 5440 .Case("nonatomic", true) 5441 .Case("atomic", true) 5442 .Case("getter", true) 5443 .Case("setter", true) 5444 .Case("strong", true) 5445 .Case("weak", true) 5446 .Default(false)) 5447 Tokens[I].int_data[0] = CXToken_Keyword; 5448 } 5449 continue; 5450 } 5451 5452 if (Cursors[I].kind == CXCursor_ObjCInstanceMethodDecl || 5453 Cursors[I].kind == CXCursor_ObjCClassMethodDecl) { 5454 IdentifierInfo *II = static_cast<IdentifierInfo *>(Tokens[I].ptr_data); 5455 if (llvm::StringSwitch<bool>(II->getName()) 5456 .Case("in", true) 5457 .Case("out", true) 5458 .Case("inout", true) 5459 .Case("oneway", true) 5460 .Case("bycopy", true) 5461 .Case("byref", true) 5462 .Default(false)) 5463 Tokens[I].int_data[0] = CXToken_Keyword; 5464 continue; 5465 } 5466 5467 if (Cursors[I].kind == CXCursor_CXXFinalAttr || 5468 Cursors[I].kind == CXCursor_CXXOverrideAttr) { 5469 Tokens[I].int_data[0] = CXToken_Keyword; 5470 continue; 5471 } 5472 } 5473 } 5474} 5475 5476extern "C" { 5477 5478void clang_annotateTokens(CXTranslationUnit TU, 5479 CXToken *Tokens, unsigned NumTokens, 5480 CXCursor *Cursors) { 5481 5482 if (NumTokens == 0 || !Tokens || !Cursors) 5483 return; 5484 5485 // Any token we don't specifically annotate will have a NULL cursor. 5486 CXCursor C = clang_getNullCursor(); 5487 for (unsigned I = 0; I != NumTokens; ++I) 5488 Cursors[I] = C; 5489 5490 ASTUnit *CXXUnit = static_cast<ASTUnit *>(TU->TUData); 5491 if (!CXXUnit) 5492 return; 5493 5494 ASTUnit::ConcurrencyCheck Check(*CXXUnit); 5495 5496 clang_annotateTokens_Data data = { TU, CXXUnit, Tokens, NumTokens, Cursors }; 5497 llvm::CrashRecoveryContext CRC; 5498 if (!RunSafely(CRC, clang_annotateTokensImpl, &data, 5499 GetSafetyThreadStackSize() * 2)) { 5500 fprintf(stderr, "libclang: crash detected while annotating tokens\n"); 5501 } 5502} 5503 5504} // end: extern "C" 5505 5506//===----------------------------------------------------------------------===// 5507// Operations for querying linkage of a cursor. 5508//===----------------------------------------------------------------------===// 5509 5510extern "C" { 5511CXLinkageKind clang_getCursorLinkage(CXCursor cursor) { 5512 if (!clang_isDeclaration(cursor.kind)) 5513 return CXLinkage_Invalid; 5514 5515 Decl *D = cxcursor::getCursorDecl(cursor); 5516 if (NamedDecl *ND = dyn_cast_or_null<NamedDecl>(D)) 5517 switch (ND->getLinkage()) { 5518 case NoLinkage: return CXLinkage_NoLinkage; 5519 case InternalLinkage: return CXLinkage_Internal; 5520 case UniqueExternalLinkage: return CXLinkage_UniqueExternal; 5521 case ExternalLinkage: return CXLinkage_External; 5522 }; 5523 5524 return CXLinkage_Invalid; 5525} 5526} // end: extern "C" 5527 5528//===----------------------------------------------------------------------===// 5529// Operations for querying language of a cursor. 5530//===----------------------------------------------------------------------===// 5531 5532static CXLanguageKind getDeclLanguage(const Decl *D) { 5533 if (!D) 5534 return CXLanguage_C; 5535 5536 switch (D->getKind()) { 5537 default: 5538 break; 5539 case Decl::ImplicitParam: 5540 case Decl::ObjCAtDefsField: 5541 case Decl::ObjCCategory: 5542 case Decl::ObjCCategoryImpl: 5543 case Decl::ObjCCompatibleAlias: 5544 case Decl::ObjCImplementation: 5545 case Decl::ObjCInterface: 5546 case Decl::ObjCIvar: 5547 case Decl::ObjCMethod: 5548 case Decl::ObjCProperty: 5549 case Decl::ObjCPropertyImpl: 5550 case Decl::ObjCProtocol: 5551 return CXLanguage_ObjC; 5552 case Decl::CXXConstructor: 5553 case Decl::CXXConversion: 5554 case Decl::CXXDestructor: 5555 case Decl::CXXMethod: 5556 case Decl::CXXRecord: 5557 case Decl::ClassTemplate: 5558 case Decl::ClassTemplatePartialSpecialization: 5559 case Decl::ClassTemplateSpecialization: 5560 case Decl::Friend: 5561 case Decl::FriendTemplate: 5562 case Decl::FunctionTemplate: 5563 case Decl::LinkageSpec: 5564 case Decl::Namespace: 5565 case Decl::NamespaceAlias: 5566 case Decl::NonTypeTemplateParm: 5567 case Decl::StaticAssert: 5568 case Decl::TemplateTemplateParm: 5569 case Decl::TemplateTypeParm: 5570 case Decl::UnresolvedUsingTypename: 5571 case Decl::UnresolvedUsingValue: 5572 case Decl::Using: 5573 case Decl::UsingDirective: 5574 case Decl::UsingShadow: 5575 return CXLanguage_CPlusPlus; 5576 } 5577 5578 return CXLanguage_C; 5579} 5580 5581extern "C" { 5582 5583enum CXAvailabilityKind clang_getCursorAvailability(CXCursor cursor) { 5584 if (clang_isDeclaration(cursor.kind)) 5585 if (Decl *D = cxcursor::getCursorDecl(cursor)) { 5586 if (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isDeleted()) 5587 return CXAvailability_Available; 5588 5589 switch (D->getAvailability()) { 5590 case AR_Available: 5591 case AR_NotYetIntroduced: 5592 return CXAvailability_Available; 5593 5594 case AR_Deprecated: 5595 return CXAvailability_Deprecated; 5596 5597 case AR_Unavailable: 5598 return CXAvailability_NotAvailable; 5599 } 5600 } 5601 5602 return CXAvailability_Available; 5603} 5604 5605static CXVersion convertVersion(VersionTuple In) { 5606 CXVersion Out = { -1, -1, -1 }; 5607 if (In.empty()) 5608 return Out; 5609 5610 Out.Major = In.getMajor(); 5611 5612 if (llvm::Optional<unsigned> Minor = In.getMinor()) 5613 Out.Minor = *Minor; 5614 else 5615 return Out; 5616 5617 if (llvm::Optional<unsigned> Subminor = In.getSubminor()) 5618 Out.Subminor = *Subminor; 5619 5620 return Out; 5621} 5622 5623int clang_getCursorPlatformAvailability(CXCursor cursor, 5624 int *always_deprecated, 5625 CXString *deprecated_message, 5626 int *always_unavailable, 5627 CXString *unavailable_message, 5628 CXPlatformAvailability *availability, 5629 int availability_size) { 5630 if (always_deprecated) 5631 *always_deprecated = 0; 5632 if (deprecated_message) 5633 *deprecated_message = cxstring::createCXString("", /*DupString=*/false); 5634 if (always_unavailable) 5635 *always_unavailable = 0; 5636 if (unavailable_message) 5637 *unavailable_message = cxstring::createCXString("", /*DupString=*/false); 5638 5639 if (!clang_isDeclaration(cursor.kind)) 5640 return 0; 5641 5642 Decl *D = cxcursor::getCursorDecl(cursor); 5643 if (!D) 5644 return 0; 5645 5646 int N = 0; 5647 for (Decl::attr_iterator A = D->attr_begin(), AEnd = D->attr_end(); A != AEnd; 5648 ++A) { 5649 if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(*A)) { 5650 if (always_deprecated) 5651 *always_deprecated = 1; 5652 if (deprecated_message) 5653 *deprecated_message = cxstring::createCXString(Deprecated->getMessage()); 5654 continue; 5655 } 5656 5657 if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(*A)) { 5658 if (always_unavailable) 5659 *always_unavailable = 1; 5660 if (unavailable_message) { 5661 *unavailable_message 5662 = cxstring::createCXString(Unavailable->getMessage()); 5663 } 5664 continue; 5665 } 5666 5667 if (AvailabilityAttr *Avail = dyn_cast<AvailabilityAttr>(*A)) { 5668 if (N < availability_size) { 5669 availability[N].Platform 5670 = cxstring::createCXString(Avail->getPlatform()->getName()); 5671 availability[N].Introduced = convertVersion(Avail->getIntroduced()); 5672 availability[N].Deprecated = convertVersion(Avail->getDeprecated()); 5673 availability[N].Obsoleted = convertVersion(Avail->getObsoleted()); 5674 availability[N].Unavailable = Avail->getUnavailable(); 5675 availability[N].Message = cxstring::createCXString(Avail->getMessage()); 5676 } 5677 ++N; 5678 } 5679 } 5680 5681 return N; 5682} 5683 5684void clang_disposeCXPlatformAvailability(CXPlatformAvailability *availability) { 5685 clang_disposeString(availability->Platform); 5686 clang_disposeString(availability->Message); 5687} 5688 5689CXLanguageKind clang_getCursorLanguage(CXCursor cursor) { 5690 if (clang_isDeclaration(cursor.kind)) 5691 return getDeclLanguage(cxcursor::getCursorDecl(cursor)); 5692 5693 return CXLanguage_Invalid; 5694} 5695 5696 /// \brief If the given cursor is the "templated" declaration 5697 /// descibing a class or function template, return the class or 5698 /// function template. 5699static Decl *maybeGetTemplateCursor(Decl *D) { 5700 if (!D) 5701 return 0; 5702 5703 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 5704 if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate()) 5705 return FunTmpl; 5706 5707 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) 5708 if (ClassTemplateDecl *ClassTmpl = RD->getDescribedClassTemplate()) 5709 return ClassTmpl; 5710 5711 return D; 5712} 5713 5714CXCursor clang_getCursorSemanticParent(CXCursor cursor) { 5715 if (clang_isDeclaration(cursor.kind)) { 5716 if (Decl *D = getCursorDecl(cursor)) { 5717 DeclContext *DC = D->getDeclContext(); 5718 if (!DC) 5719 return clang_getNullCursor(); 5720 5721 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 5722 getCursorTU(cursor)); 5723 } 5724 } 5725 5726 if (clang_isStatement(cursor.kind) || clang_isExpression(cursor.kind)) { 5727 if (Decl *D = getCursorDecl(cursor)) 5728 return MakeCXCursor(D, getCursorTU(cursor)); 5729 } 5730 5731 return clang_getNullCursor(); 5732} 5733 5734CXCursor clang_getCursorLexicalParent(CXCursor cursor) { 5735 if (clang_isDeclaration(cursor.kind)) { 5736 if (Decl *D = getCursorDecl(cursor)) { 5737 DeclContext *DC = D->getLexicalDeclContext(); 5738 if (!DC) 5739 return clang_getNullCursor(); 5740 5741 return MakeCXCursor(maybeGetTemplateCursor(cast<Decl>(DC)), 5742 getCursorTU(cursor)); 5743 } 5744 } 5745 5746 // FIXME: Note that we can't easily compute the lexical context of a 5747 // statement or expression, so we return nothing. 5748 return clang_getNullCursor(); 5749} 5750 5751CXFile clang_getIncludedFile(CXCursor cursor) { 5752 if (cursor.kind != CXCursor_InclusionDirective) 5753 return 0; 5754 5755 InclusionDirective *ID = getCursorInclusionDirective(cursor); 5756 return (void *)ID->getFile(); 5757} 5758 5759CXSourceRange clang_Cursor_getCommentRange(CXCursor C) { 5760 if (!clang_isDeclaration(C.kind)) 5761 return clang_getNullRange(); 5762 5763 const Decl *D = getCursorDecl(C); 5764 ASTContext &Context = getCursorContext(C); 5765 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 5766 if (!RC) 5767 return clang_getNullRange(); 5768 5769 return cxloc::translateSourceRange(Context, RC->getSourceRange()); 5770} 5771 5772CXString clang_Cursor_getRawCommentText(CXCursor C) { 5773 if (!clang_isDeclaration(C.kind)) 5774 return createCXString((const char *) NULL); 5775 5776 const Decl *D = getCursorDecl(C); 5777 ASTContext &Context = getCursorContext(C); 5778 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 5779 StringRef RawText = RC ? RC->getRawText(Context.getSourceManager()) : 5780 StringRef(); 5781 5782 // Don't duplicate the string because RawText points directly into source 5783 // code. 5784 return createCXString(RawText, false); 5785} 5786 5787CXString clang_Cursor_getBriefCommentText(CXCursor C) { 5788 if (!clang_isDeclaration(C.kind)) 5789 return createCXString((const char *) NULL); 5790 5791 const Decl *D = getCursorDecl(C); 5792 const ASTContext &Context = getCursorContext(C); 5793 const RawComment *RC = Context.getRawCommentForAnyRedecl(D); 5794 5795 if (RC) { 5796 StringRef BriefText = RC->getBriefText(Context); 5797 5798 // Don't duplicate the string because RawComment ensures that this memory 5799 // will not go away. 5800 return createCXString(BriefText, false); 5801 } 5802 5803 return createCXString((const char *) NULL); 5804} 5805 5806CXComment clang_Cursor_getParsedComment(CXCursor C) { 5807 if (!clang_isDeclaration(C.kind)) 5808 return cxcomment::createCXComment(NULL, NULL); 5809 5810 const Decl *D = getCursorDecl(C); 5811 const ASTContext &Context = getCursorContext(C); 5812 const comments::FullComment *FC = Context.getCommentForDecl(D); 5813 5814 return cxcomment::createCXComment(FC, getCursorTU(C)); 5815} 5816 5817} // end: extern "C" 5818 5819//===----------------------------------------------------------------------===// 5820// C++ AST instrospection. 5821//===----------------------------------------------------------------------===// 5822 5823extern "C" { 5824unsigned clang_CXXMethod_isStatic(CXCursor C) { 5825 if (!clang_isDeclaration(C.kind)) 5826 return 0; 5827 5828 CXXMethodDecl *Method = 0; 5829 Decl *D = cxcursor::getCursorDecl(C); 5830 if (FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(D)) 5831 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl()); 5832 else 5833 Method = dyn_cast_or_null<CXXMethodDecl>(D); 5834 return (Method && Method->isStatic()) ? 1 : 0; 5835} 5836 5837unsigned clang_CXXMethod_isVirtual(CXCursor C) { 5838 if (!clang_isDeclaration(C.kind)) 5839 return 0; 5840 5841 CXXMethodDecl *Method = 0; 5842 Decl *D = cxcursor::getCursorDecl(C); 5843 if (FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(D)) 5844 Method = dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl()); 5845 else 5846 Method = dyn_cast_or_null<CXXMethodDecl>(D); 5847 return (Method && Method->isVirtual()) ? 1 : 0; 5848} 5849} // end: extern "C" 5850 5851//===----------------------------------------------------------------------===// 5852// Attribute introspection. 5853//===----------------------------------------------------------------------===// 5854 5855extern "C" { 5856CXType clang_getIBOutletCollectionType(CXCursor C) { 5857 if (C.kind != CXCursor_IBOutletCollectionAttr) 5858 return cxtype::MakeCXType(QualType(), cxcursor::getCursorTU(C)); 5859 5860 IBOutletCollectionAttr *A = 5861 cast<IBOutletCollectionAttr>(cxcursor::getCursorAttr(C)); 5862 5863 return cxtype::MakeCXType(A->getInterface(), cxcursor::getCursorTU(C)); 5864} 5865} // end: extern "C" 5866 5867//===----------------------------------------------------------------------===// 5868// Inspecting memory usage. 5869//===----------------------------------------------------------------------===// 5870 5871typedef std::vector<CXTUResourceUsageEntry> MemUsageEntries; 5872 5873static inline void createCXTUResourceUsageEntry(MemUsageEntries &entries, 5874 enum CXTUResourceUsageKind k, 5875 unsigned long amount) { 5876 CXTUResourceUsageEntry entry = { k, amount }; 5877 entries.push_back(entry); 5878} 5879 5880extern "C" { 5881 5882const char *clang_getTUResourceUsageName(CXTUResourceUsageKind kind) { 5883 const char *str = ""; 5884 switch (kind) { 5885 case CXTUResourceUsage_AST: 5886 str = "ASTContext: expressions, declarations, and types"; 5887 break; 5888 case CXTUResourceUsage_Identifiers: 5889 str = "ASTContext: identifiers"; 5890 break; 5891 case CXTUResourceUsage_Selectors: 5892 str = "ASTContext: selectors"; 5893 break; 5894 case CXTUResourceUsage_GlobalCompletionResults: 5895 str = "Code completion: cached global results"; 5896 break; 5897 case CXTUResourceUsage_SourceManagerContentCache: 5898 str = "SourceManager: content cache allocator"; 5899 break; 5900 case CXTUResourceUsage_AST_SideTables: 5901 str = "ASTContext: side tables"; 5902 break; 5903 case CXTUResourceUsage_SourceManager_Membuffer_Malloc: 5904 str = "SourceManager: malloc'ed memory buffers"; 5905 break; 5906 case CXTUResourceUsage_SourceManager_Membuffer_MMap: 5907 str = "SourceManager: mmap'ed memory buffers"; 5908 break; 5909 case CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc: 5910 str = "ExternalASTSource: malloc'ed memory buffers"; 5911 break; 5912 case CXTUResourceUsage_ExternalASTSource_Membuffer_MMap: 5913 str = "ExternalASTSource: mmap'ed memory buffers"; 5914 break; 5915 case CXTUResourceUsage_Preprocessor: 5916 str = "Preprocessor: malloc'ed memory"; 5917 break; 5918 case CXTUResourceUsage_PreprocessingRecord: 5919 str = "Preprocessor: PreprocessingRecord"; 5920 break; 5921 case CXTUResourceUsage_SourceManager_DataStructures: 5922 str = "SourceManager: data structures and tables"; 5923 break; 5924 case CXTUResourceUsage_Preprocessor_HeaderSearch: 5925 str = "Preprocessor: header search tables"; 5926 break; 5927 } 5928 return str; 5929} 5930 5931CXTUResourceUsage clang_getCXTUResourceUsage(CXTranslationUnit TU) { 5932 if (!TU) { 5933 CXTUResourceUsage usage = { (void*) 0, 0, 0 }; 5934 return usage; 5935 } 5936 5937 ASTUnit *astUnit = static_cast<ASTUnit*>(TU->TUData); 5938 OwningPtr<MemUsageEntries> entries(new MemUsageEntries()); 5939 ASTContext &astContext = astUnit->getASTContext(); 5940 5941 // How much memory is used by AST nodes and types? 5942 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST, 5943 (unsigned long) astContext.getASTAllocatedMemory()); 5944 5945 // How much memory is used by identifiers? 5946 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Identifiers, 5947 (unsigned long) astContext.Idents.getAllocator().getTotalMemory()); 5948 5949 // How much memory is used for selectors? 5950 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_Selectors, 5951 (unsigned long) astContext.Selectors.getTotalMemory()); 5952 5953 // How much memory is used by ASTContext's side tables? 5954 createCXTUResourceUsageEntry(*entries, CXTUResourceUsage_AST_SideTables, 5955 (unsigned long) astContext.getSideTableAllocatedMemory()); 5956 5957 // How much memory is used for caching global code completion results? 5958 unsigned long completionBytes = 0; 5959 if (GlobalCodeCompletionAllocator *completionAllocator = 5960 astUnit->getCachedCompletionAllocator().getPtr()) { 5961 completionBytes = completionAllocator->getTotalMemory(); 5962 } 5963 createCXTUResourceUsageEntry(*entries, 5964 CXTUResourceUsage_GlobalCompletionResults, 5965 completionBytes); 5966 5967 // How much memory is being used by SourceManager's content cache? 5968 createCXTUResourceUsageEntry(*entries, 5969 CXTUResourceUsage_SourceManagerContentCache, 5970 (unsigned long) astContext.getSourceManager().getContentCacheSize()); 5971 5972 // How much memory is being used by the MemoryBuffer's in SourceManager? 5973 const SourceManager::MemoryBufferSizes &srcBufs = 5974 astUnit->getSourceManager().getMemoryBufferSizes(); 5975 5976 createCXTUResourceUsageEntry(*entries, 5977 CXTUResourceUsage_SourceManager_Membuffer_Malloc, 5978 (unsigned long) srcBufs.malloc_bytes); 5979 createCXTUResourceUsageEntry(*entries, 5980 CXTUResourceUsage_SourceManager_Membuffer_MMap, 5981 (unsigned long) srcBufs.mmap_bytes); 5982 createCXTUResourceUsageEntry(*entries, 5983 CXTUResourceUsage_SourceManager_DataStructures, 5984 (unsigned long) astContext.getSourceManager() 5985 .getDataStructureSizes()); 5986 5987 // How much memory is being used by the ExternalASTSource? 5988 if (ExternalASTSource *esrc = astContext.getExternalSource()) { 5989 const ExternalASTSource::MemoryBufferSizes &sizes = 5990 esrc->getMemoryBufferSizes(); 5991 5992 createCXTUResourceUsageEntry(*entries, 5993 CXTUResourceUsage_ExternalASTSource_Membuffer_Malloc, 5994 (unsigned long) sizes.malloc_bytes); 5995 createCXTUResourceUsageEntry(*entries, 5996 CXTUResourceUsage_ExternalASTSource_Membuffer_MMap, 5997 (unsigned long) sizes.mmap_bytes); 5998 } 5999 6000 // How much memory is being used by the Preprocessor? 6001 Preprocessor &pp = astUnit->getPreprocessor(); 6002 createCXTUResourceUsageEntry(*entries, 6003 CXTUResourceUsage_Preprocessor, 6004 pp.getTotalMemory()); 6005 6006 if (PreprocessingRecord *pRec = pp.getPreprocessingRecord()) { 6007 createCXTUResourceUsageEntry(*entries, 6008 CXTUResourceUsage_PreprocessingRecord, 6009 pRec->getTotalMemory()); 6010 } 6011 6012 createCXTUResourceUsageEntry(*entries, 6013 CXTUResourceUsage_Preprocessor_HeaderSearch, 6014 pp.getHeaderSearchInfo().getTotalMemory()); 6015 6016 CXTUResourceUsage usage = { (void*) entries.get(), 6017 (unsigned) entries->size(), 6018 entries->size() ? &(*entries)[0] : 0 }; 6019 entries.take(); 6020 return usage; 6021} 6022 6023void clang_disposeCXTUResourceUsage(CXTUResourceUsage usage) { 6024 if (usage.data) 6025 delete (MemUsageEntries*) usage.data; 6026} 6027 6028} // end extern "C" 6029 6030void clang::PrintLibclangResourceUsage(CXTranslationUnit TU) { 6031 CXTUResourceUsage Usage = clang_getCXTUResourceUsage(TU); 6032 for (unsigned I = 0; I != Usage.numEntries; ++I) 6033 fprintf(stderr, " %s: %lu\n", 6034 clang_getTUResourceUsageName(Usage.entries[I].kind), 6035 Usage.entries[I].amount); 6036 6037 clang_disposeCXTUResourceUsage(Usage); 6038} 6039 6040//===----------------------------------------------------------------------===// 6041// Misc. utility functions. 6042//===----------------------------------------------------------------------===// 6043 6044/// Default to using an 8 MB stack size on "safety" threads. 6045static unsigned SafetyStackThreadSize = 8 << 20; 6046 6047namespace clang { 6048 6049bool RunSafely(llvm::CrashRecoveryContext &CRC, 6050 void (*Fn)(void*), void *UserData, 6051 unsigned Size) { 6052 if (!Size) 6053 Size = GetSafetyThreadStackSize(); 6054 if (Size) 6055 return CRC.RunSafelyOnThread(Fn, UserData, Size); 6056 return CRC.RunSafely(Fn, UserData); 6057} 6058 6059unsigned GetSafetyThreadStackSize() { 6060 return SafetyStackThreadSize; 6061} 6062 6063void SetSafetyThreadStackSize(unsigned Value) { 6064 SafetyStackThreadSize = Value; 6065} 6066 6067} 6068 6069void clang::setThreadBackgroundPriority() { 6070 // FIXME: Move to llvm/Support and make it cross-platform. 6071#ifdef __APPLE__ 6072 setpriority(PRIO_DARWIN_THREAD, 0, PRIO_DARWIN_BG); 6073#endif 6074} 6075 6076void cxindex::printDiagsToStderr(ASTUnit *Unit) { 6077 if (!Unit) 6078 return; 6079 6080 for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(), 6081 DEnd = Unit->stored_diag_end(); 6082 D != DEnd; ++D) { 6083 CXStoredDiagnostic Diag(*D, Unit->getASTContext().getLangOpts()); 6084 CXString Msg = clang_formatDiagnostic(&Diag, 6085 clang_defaultDiagnosticDisplayOptions()); 6086 fprintf(stderr, "%s\n", clang_getCString(Msg)); 6087 clang_disposeString(Msg); 6088 } 6089#ifdef LLVM_ON_WIN32 6090 // On Windows, force a flush, since there may be multiple copies of 6091 // stderr and stdout in the file system, all with different buffers 6092 // but writing to the same device. 6093 fflush(stderr); 6094#endif 6095} 6096 6097extern "C" { 6098 6099CXString clang_getClangVersion() { 6100 return createCXString(getClangFullVersion()); 6101} 6102 6103} // end: extern "C" 6104 6105